@voithos-labs/aragonite 0.10.4 → 0.10.7

package/dist/core/nodes.d.ts

@@ -35,8 +35,11 @@ export interface ThematicBreakMetadata {
     marker: string;
 }
 export interface LinkReferenceDefinitionMetadata {
+    /** The label's text, unnormalized; a label spanning lines keeps its breaks as `\n`. */
     label: string;
+    /** Escapes resolved and percent-encoded, the value an inline link's `url` holds. */
     url?: string;
+    /** Escapes resolved, the value an inline link's `title` holds. */
     title?: string;
 }
 export type TableAlignment = 'none' | 'left' | 'center' | 'right';
@@ -46,6 +49,9 @@ export interface TableMetadata {
 }
 export interface TableRowMetadata {
     isHeader: boolean;
+    /** A body row's cells past the header's count, as written: GFM renders none of them, and the
+     *  row's rebuild writes them back after its rendered cells. Absent when there are none. */
+    surplusCells?: readonly string[];
 }
 export interface BlockquoteMetadata {
     quoteDepth: number;
@@ -73,18 +79,12 @@ export interface BlockMetadataByKind {
     list: ListMetadata;
     listItem: ListItemMetadata;
 }
-/**
- * The one sanctioned metadata cast, for contexts a narrowed `BuiltinCstNode` arm cannot reach:
- * a generic `K`, or a full `CstNode` whose branded plugin arm blocks `kind` narrowing. Prefer
- * reading `node.metadata` off a narrowed arm. Pass the kind you have already established.
- */
+/** The one allowed metadata cast, for a generic `K` or a full `CstNode` that cannot narrow; prefer
+ *  a narrowed node's `node.metadata`. Pass the kind you have already established. */
 export declare function metadataOf<K extends keyof BlockMetadataByKind>(node: CstNode, kind: K): BlockMetadataByKind[K];
 export declare function metadataOf<K extends keyof BlockMetadataByKind>(node: NodeView, kind: K): BytesView<BlockMetadataByKind[K]>;
-/**
- * `BlockMetadata` is closed over the built-ins, so bridging a plugin's shape needs a cast and
- * this pair is the one place it lives. Keep the stored shape primitive-valued: the one-level
- * undo clone (G1.6) shallow-copies metadata.
- */
+/** The one cast bridging a plugin's shape into the built-in `BlockMetadata`. Keep the shape
+ *  primitive-valued: undo's one-level clone shallow-copies metadata (G1.6). */
 export declare function setPluginMetadata<T>(node: CstNode, data: T): void;
 export declare function getPluginMetadata<T>(node: NodeView): T | undefined;
 /**
@@ -99,8 +99,8 @@ interface BlockNodeBase {
     ownerEpoch?: number;
 }
 /**
- * G1.5 forbids `children` and the container structural fields on non-containers, so the arms pin
- * them `undefined` and the union rejects a leaf that grew a child at the type level.
+ * A leaf never has `children` or the container fields (G1.5), so the leaf members type them
+ * `undefined` and the union rejects a leaf that grew a child at compile time.
  */
 interface LeafBlockNodeBase extends BlockNodeBase {
     children?: undefined;
@@ -109,11 +109,8 @@ interface LeafBlockNodeBase extends BlockNodeBase {
     childIds?: undefined;
     childSpans?: undefined;
 }
-/**
- * G1.5 is one-directional (a container may be transiently childless mid-edit), so every
- * structural field stays optional. `childIds` mirrors `children` for keyed rendering;
- * `childSpans` records where each child's bytes sit in `raw` (`schema/child-spans.ts`).
- */
+/** A container may be briefly childless mid-edit (G1.5), so every structural field stays optional;
+ *  `childSpans` records where each child's bytes sit in `raw`. */
 interface ContainerBlockNodeBase extends BlockNodeBase {
     children?: CstNode[];
     innerPrefix?: string;
@@ -182,9 +179,9 @@ export interface TableRowNode extends ContainerBlockNodeBase {
     metadata: TableRowMetadata;
 }
 /**
- * A branded-string kind, so this arm is NOT discriminable by `switch (node.kind)`: narrow past
- * it with `isBuiltinBlockNode` first. A plugin block may be a leaf or a container, so the
- * structural fields stay optional.
+ * A branded-string kind, so `switch (node.kind)` cannot narrow this member: narrow past it with
+ * `isBuiltinBlockNode` first. A plugin block may be a leaf or a container, so the structural
+ * fields stay optional.
  */
 export interface PluginBlockNode extends BlockNodeBase {
     kind: PluginBlockKind;
@@ -198,24 +195,19 @@ export interface PluginBlockNode extends BlockNodeBase {
 /** A genuine discriminated union: `switch (node.kind)` narrows `node.metadata` with no cast. */
 export type BuiltinCstNode = ParagraphNode | HeadingNode | SetextHeadingNode | FencedCodeNode | ThematicBreakNode | IndentedCodeNode | HtmlBlockNode | LinkReferenceDefinitionNode | TableCellNode | UnrecognizedNode | BlockquoteNode | ListNode | ListItemNode | TableNode | TableRowNode;
 /**
- * The open `PluginBlockNode` arm does not discriminate, so full-union `kind` checks do not
- * narrow: reach the discriminated world through `isBuiltinBlockNode`. Common fields (`raw`,
- * `leadingTrivia`, `kind`) project across every arm and read without narrowing.
+ * The open `PluginBlockNode` member has no literal kind, so `kind` checks on the full union do
+ * not narrow: go through `isBuiltinBlockNode` first. Common fields (`raw`, `leadingTrivia`,
+ * `kind`) exist on every member and read without narrowing.
  */
 export type CstNode = BuiltinCstNode | PluginBlockNode;
 /**
- * The door to the `switch (node.kind)` narrowing the branded plugin arm blocks. Mirrored for
- * views, so a reader that narrows a `NodeView` reads each arm's metadata with no `metadataOf`.
+ * The one way into the `switch (node.kind)` narrowing the plugin member blocks. Overloaded for
+ * views, so code that narrows a `NodeView` reads each member's metadata with no `metadataOf`.
  */
 export declare function isBuiltinBlockNode(node: CstNode): node is BuiltinCstNode;
 export declare function isBuiltinBlockNode(node: NodeView): node is BytesView<BuiltinCstNode>;
-/**
- * The ONE place the runtime-kind construction cast lives. A construction door, not the
- * view-to-mutable strip door: the spread returns a FRESH object, so passing a view mints a copy
- * instead of stripping its readonly-ness, which is why G4.13 sanctions this file. Fields are not
- * checked against the arm, so a metadata-less node of a metadata-carrying kind is mintable (a
- * transient re-parse probe does this) and its `metadata` must not be read before re-parse.
- */
+/** The one cast from a runtime kind string to `CstNode`; the spread copies, so a view stays read-only
+ *  (G4.13). Metadata isn't checked: a node made without it must not be read before its re-parse. */
 export declare function makeBlockNode(fields: {
     kind: AnyBlockKind;
     leadingTrivia: string;
@@ -232,8 +224,8 @@ export interface Document {
     prefix: string;
     children: CstNode[];
     suffix: string;
-    /** The root's parallel id array while a caller keeps one here — the editor's own live ids
-     *  are editor state, but the splice doors maintain whatever array the parent carries. */
+    /** The root's parallel id array, when a caller keeps one here: the editor's own live ids are
+     *  editor state, but the splice operations maintain whatever array the parent carries. */
     childIds?: string[];
 }
 export type InlineNodeKind = 'text' | 'emphasis' | 'strong' | 'strikethrough' | 'inlineCode' | 'link' | 'image' | 'autolink' | 'hardLineBreak' | 'escape' | 'entityReference' | 'unresolvedReference' | 'rawHtml';
@@ -245,7 +237,8 @@ export type PluginInlineKind = string & {
 export type AnyInlineKind = InlineNodeKind | PluginInlineKind;
 export declare const INLINE_KIND_TABLE: Record<InlineNodeKind, true>;
 export declare function isBuiltinInlineKind(kind: AnyInlineKind): kind is InlineNodeKind;
-/** start/end are byte offsets into the parent block's raw, including markers. */
+/** start/end are byte offsets into the parent block's raw, including markers. Optional keys are
+ *  omitted, never set to `undefined`, so a serializer can tell "no title" from "empty title". */
 export interface InlineNode {
     kind: AnyInlineKind;
     start: number;
@@ -264,15 +257,11 @@ export interface InlineNode {
     /** Discriminator for `unresolvedReference` nodes: which form they would have been. */
     refKind?: 'link' | 'image';
     /**
-     * Stamped by the scan when a plugin rung claimed these bytes, derived per scan and never
+     * Set by the scan when a plugin handler claimed these bytes, derived per scan and never
      * persisted. Write paths read it to re-serialize in the claiming syntax, not built-in GFM.
      */
     syntaxClaim?: InlineSyntaxClaim;
 }
-/**
- * Optional keys are omitted rather than set to `undefined`, so a serializer can tell "no title"
- * from "empty title" and reproduce a node that never carried one.
- */
 /**
  * How an image sits inside its `|WxH` frame: the image point (`x`%, `y`%) pinned to the same
  * point of the frame, at `z` times the smallest scale that fills it. `{50, 50, 1}` is a plain
@@ -298,13 +287,14 @@ export interface ImageFields {
     label?: string;
 }
 /**
- * Re-serializes an image an inline rung minted over its own bytes: `source` in, its replacement
- * in the rung's syntax out, or `null` to decline the edit rather than rewrite the bytes as GFM.
+ * Re-serializes an image a plugin handler created over its own bytes: `source` in, its
+ * replacement in the plugin's syntax out, or `null` to decline the edit rather than rewrite the
+ * bytes as GFM.
  */
 export type ImageSyntaxRewriter = (source: string, fields: ImageFields) => string | null;
-/** What the scan records on a node an inline rung claimed. */
+/** What the scan records on a node a plugin inline handler claimed. */
 export interface InlineSyntaxClaim {
-    /** The claiming rung's prefix: its bare trigger, or its multi-char prefix. */
+    /** The claiming handler's prefix: its bare trigger, or its multi-character prefix. */
     prefix: string;
     rewriteImage?: ImageSyntaxRewriter;
 }

package/dist/core/nodes.js

@@ -28,11 +28,8 @@ export function metadataOf(node, kind) {
     void kind;
     return node.metadata;
 }
-/**
- * `BlockMetadata` is closed over the built-ins, so bridging a plugin's shape needs a cast and
- * this pair is the one place it lives. Keep the stored shape primitive-valued: the one-level
- * undo clone (G1.6) shallow-copies metadata.
- */
+/** The one cast bridging a plugin's shape into the built-in `BlockMetadata`. Keep the shape
+ *  primitive-valued: undo's one-level clone shallow-copies metadata (G1.6). */
 export function setPluginMetadata(node, data) {
     node.metadata = data;
 }
@@ -53,13 +50,8 @@ export function headingLevel(node) {
 export function isBuiltinBlockNode(node) {
     return isBuiltinBlockKind(node.kind);
 }
-/**
- * The ONE place the runtime-kind construction cast lives. A construction door, not the
- * view-to-mutable strip door: the spread returns a FRESH object, so passing a view mints a copy
- * instead of stripping its readonly-ness, which is why G4.13 sanctions this file. Fields are not
- * checked against the arm, so a metadata-less node of a metadata-carrying kind is mintable (a
- * transient re-parse probe does this) and its `metadata` must not be read before re-parse.
- */
+/** The one cast from a runtime kind string to `CstNode`; the spread copies, so a view stays read-only
+ *  (G4.13). Metadata isn't checked: a node made without it must not be read before its re-parse. */
 export function makeBlockNode(fields) {
     return { ...fields };
 }

package/dist/core/parser.d.ts

@@ -3,66 +3,59 @@
  * Per-kind parsers live in parsers/; this file holds dispatch and shared utilities only.
  */
 import type { CstNode, Document } from './nodes';
-import { type ParsedLine } from './lines';
+import { isBlankLine, type ParsedLine } from './lines';
 import { type GrammarView } from '../schema/block-openers';
 /**
- * Container-nesting cap: past it the remaining prefix parses as paragraph content instead of
- * recursing, so pathological input degrades rather than overflowing the stack. Sits well under
- * the empirical crash point, with headroom for the tree walks that recurse to the same depth.
- * Byte-preserving, since only a top-level node's `raw` serializes and that is fixed first.
+ * Container-nesting cap: past it the rest parses as paragraph text instead of recursing, so deep
+ * input cannot overflow the stack. Bytes are unaffected: the top-level `raw` is fixed first.
  */
 export declare const MAX_NESTING_DEPTH = 512;
 /** Whether `source` is a whole document or one block's bytes read standalone. */
 export type ParseScope = 'document' | 'fragment';
-/**
- * Parse GFM to a lossless CST. `opts.grammar` is the per-instance grammar view, defaulting to
- * the global openers. It filters only the TOP-LEVEL opener dispatch: nested container reparses
- * and the paragraph-interrupt scan read the global grammar, the documented enablement boundary,
- * so a top-level disabled kind is skipped and a nested one is not. `opts.scope` reaches openers
- * as `ctx.isDocumentParse`; it defaults to `'document'`, so whole-source callers need nothing.
- */
+/** Parse GFM to a lossless CST, with every installed plugin's openers and `'document'` scope by
+ *  default. Code inside the editor calls {@link readBlocks}, which takes both. */
 export declare function parse(source: string, opts?: {
     grammar?: GrammarView;
     scope?: ParseScope;
 }): Document;
+/** `parse` for code inside the editor: the grammar is the editor's, so it is never left out. */
+export declare function readBlocks(source: string, read: {
+    grammar: GrammarView;
+    scope: ParseScope;
+}): Document;
 interface ParseBlocksResult {
     children: CstNode[];
     suffix: string;
 }
 /**
- * The seam block-incremental parsing re-parses ranges through: a block-aligned window parses
- * identically to a full parse of the window's text. A window is a FRAGMENT unless its caller
- * says otherwise, so `parse` alone defaults to document scope. Blank-line rule
- * (`design/syntax-tree.md`): the first blank line of a run separates and folds into trivia;
- * every later one is an empty paragraph carrying its own bytes.
+ * A task item's body read on its own, as a write into the item's first paragraph reads it: the
+ * line after the task marker is paragraph text (GFM task lists), and later lines parse as blocks.
  */
-export declare function parseBlocks(lines: ParsedLine[], start: number, end: number, grammar?: GrammarView, depth?: number, isDocumentParse?: boolean): ParseBlocksResult;
+export declare function parseTaskItemBody(source: string, grammar: GrammarView): Document;
+/** Parse `lines[start, end)` into blocks; a block-aligned window parses as its text would whole
+ *  (`docs/design/syntax-tree.md` § Blank lines). `firstLineIsParagraph` forces paragraph text. */
+export declare function parseBlocks(lines: ParsedLine[], start: number, end: number, read: {
+    grammar: GrammarView;
+    scope: ParseScope;
+    depth?: number;
+    firstLineIsParagraph?: boolean;
+}): ParseBlocksResult;
 export interface ContainerBodyWrap {
-    /** A chrome line of the container's own sits above the body (`:::note`, `<summary>`). */
+    /** A fence line of the container's own sits above the body (`:::note`, `<summary>`). */
     afterOpenerLine?: boolean;
-    /** A chrome line of the container's own sits below the body (`:::`, `</details>`). */
+    /** A fence line of the container's own sits below the body (`:::`, `</details>`). */
     beforeCloserLine?: boolean;
 }
-/**
- * Parse a container body between the container's own chrome lines; a body starting at the
- * container's own first line (blockquote, list item) has no wrap and uses `parse`. A blank line
- * against a chrome line separates as it does between blocks, landing in `prefix`/`suffix` while
- * the rest of its run materializes as body content; one with no body on its far side separated
- * nothing and stays content. `opts.scope` is required: a new entry cannot recover it (G4.27).
- */
+/** Parse a body between the container's own fence lines (`docs/design/syntax-tree.md` § Blank
+ *  lines); a body on the container's first line uses `parse`. `opts.scope` is required (G4.27). */
 export declare function parseContainerBody(bodyText: string, wrap: ContainerBodyWrap, opts: {
     scope: ParseScope;
     depth?: number;
+    grammar: GrammarView;
 }): Document;
-export declare function isBlankLine(text: string): boolean;
-/**
- * Nothing but blank lines — what the blank-line rule mints a block from. Blankness is the
- * parser's (GFM §2.1), never `String.trim()`: a non-breaking space is content.
- */
-export declare function isBlankSource(source: string): boolean;
+export { isBlankLine };
 export declare function isBlankParagraph(node: {
     kind: string;
     raw: string;
 }): boolean;
 export declare function joinRaw(lines: ParsedLine[], startIndex: number, endIndex: number): string;
-export {};

package/dist/core/parser.js

@@ -2,8 +2,8 @@
  * Single-pass GFM block parser, producing a CST where serialize(parse(source)) === source.
  * Per-kind parsers live in parsers/; this file holds dispatch and shared utilities only.
  */
-import { DEV } from 'esm-env';
-import { splitLines } from './lines';
+import { isDevChecks } from '../env';
+import { isBlankLine, isBlankText, splitLines } from './lines';
 import { perfEnabled, recordParse } from '../perf/instruments';
 import { defaultGrammarView } from '../schema/block-openers';
 import { assertInvariant } from '../assert';
@@ -11,43 +11,53 @@ import { parseParagraph } from './parsers/paragraph';
 import { registerBuiltInOpeners } from './parsers/built-in-openers';
 import { registerTableCompleter } from './parsers/table-completion';
 registerBuiltInOpeners();
-// The Enter completer is the typed-entry twin of the table grammar, so it loads here rather
-// than behind a side-effect import the production build tree-shakes away.
+// The Enter completer is the typing-side counterpart of the table grammar, so it loads here
+// rather than behind a side-effect import the production build tree-shakes away.
 registerTableCompleter();
 /**
- * Container-nesting cap: past it the remaining prefix parses as paragraph content instead of
- * recursing, so pathological input degrades rather than overflowing the stack. Sits well under
- * the empirical crash point, with headroom for the tree walks that recurse to the same depth.
- * Byte-preserving, since only a top-level node's `raw` serializes and that is fixed first.
+ * Container-nesting cap: past it the rest parses as paragraph text instead of recursing, so deep
+ * input cannot overflow the stack. Bytes are unaffected: the top-level `raw` is fixed first.
  */
 export const MAX_NESTING_DEPTH = 512;
-/**
- * Parse GFM to a lossless CST. `opts.grammar` is the per-instance grammar view, defaulting to
- * the global openers. It filters only the TOP-LEVEL opener dispatch: nested container reparses
- * and the paragraph-interrupt scan read the global grammar, the documented enablement boundary,
- * so a top-level disabled kind is skipped and a nested one is not. `opts.scope` reaches openers
- * as `ctx.isDocumentParse`; it defaults to `'document'`, so whole-source callers need nothing.
- */
+/** Parse GFM to a lossless CST, with every installed plugin's openers and `'document'` scope by
+ *  default. Code inside the editor calls {@link readBlocks}, which takes both. */
 export function parse(source, opts) {
+    return readBlocks(source, {
+        grammar: opts?.grammar ?? defaultGrammarView,
+        scope: opts?.scope ?? 'document'
+    });
+}
+/** `parse` for code inside the editor: the grammar is the editor's, so it is never left out. */
+export function readBlocks(source, read) {
     const t0 = perfEnabled() ? performance.now() : 0;
     const lines = splitLines(source);
-    const result = parseBlocks(lines, 0, lines.length, opts?.grammar ?? defaultGrammarView, 0, (opts?.scope ?? 'document') === 'document');
+    const result = parseBlocks(lines, 0, lines.length, read);
     if (perfEnabled())
         recordParse(performance.now() - t0, result.children.length);
     return { kind: 'document', prefix: '', children: result.children, suffix: result.suffix };
 }
 /**
- * The seam block-incremental parsing re-parses ranges through: a block-aligned window parses
- * identically to a full parse of the window's text. A window is a FRAGMENT unless its caller
- * says otherwise, so `parse` alone defaults to document scope. Blank-line rule
- * (`design/syntax-tree.md`): the first blank line of a run separates and folds into trivia;
- * every later one is an empty paragraph carrying its own bytes.
+ * A task item's body read on its own, as a write into the item's first paragraph reads it: the
+ * line after the task marker is paragraph text (GFM task lists), and later lines parse as blocks.
  */
-export function parseBlocks(lines, start, end, grammar = defaultGrammarView, depth = 0, isDocumentParse = false) {
+export function parseTaskItemBody(source, grammar) {
+    const lines = splitLines(source);
+    const result = parseBlocks(lines, 0, lines.length, {
+        grammar,
+        scope: 'fragment',
+        firstLineIsParagraph: true
+    });
+    return { kind: 'document', prefix: '', children: result.children, suffix: result.suffix };
+}
+/** Parse `lines[start, end)` into blocks; a block-aligned window parses as its text would whole
+ *  (`docs/design/syntax-tree.md` § Blank lines). `firstLineIsParagraph` forces paragraph text. */
+export function parseBlocks(lines, start, end, read) {
+    const { grammar, depth = 0, firstLineIsParagraph = false } = read;
+    const isDocumentParse = read.scope === 'document';
     const children = [];
     let pendingTrivia = '';
-    // Nothing precedes the window's first block, so its separator slot opens already spent —
-    // which is what makes a leading run materialize in full.
+    // Nothing precedes the window's first block, so its separator is already spent, which is
+    // what makes a leading run of blank lines materialize in full.
     let separatorSpent = true;
     let index = start;
     while (index < end) {
@@ -68,7 +78,7 @@ export function parseBlocks(lines, start, end, grammar = defaultGrammarView, dep
             index++;
             continue;
         }
-        // Minted fresh per block, so an opener that retains the context is never re-stamped.
+        // Created fresh per block, so an opener that keeps the context never sees it rewritten.
         const ctx = {
             lines,
             index,
@@ -79,7 +89,9 @@ export function parseBlocks(lines, start, end, grammar = defaultGrammarView, dep
             grammar,
             depth
         };
-        const { node, consumed } = parseNextBlock(ctx);
+        const { node, consumed } = firstLineIsParagraph && index === start
+            ? parseParagraph(lines, index, end, pendingTrivia, grammar)
+            : parseNextBlock(ctx);
         children.push(node);
         pendingTrivia = '';
         separatorSpent = false;
@@ -87,13 +99,8 @@ export function parseBlocks(lines, start, end, grammar = defaultGrammarView, dep
     }
     return { children, suffix: pendingTrivia };
 }
-/**
- * Parse a container body between the container's own chrome lines; a body starting at the
- * container's own first line (blockquote, list item) has no wrap and uses `parse`. A blank line
- * against a chrome line separates as it does between blocks, landing in `prefix`/`suffix` while
- * the rest of its run materializes as body content; one with no body on its far side separated
- * nothing and stays content. `opts.scope` is required: a new entry cannot recover it (G4.27).
- */
+/** Parse a body between the container's own fence lines (`docs/design/syntax-tree.md` § Blank
+ *  lines); a body on the container's first line uses `parse`. `opts.scope` is required (G4.27). */
 export function parseContainerBody(bodyText, wrap, opts) {
     const lines = splitLines(bodyText);
     let first = 0;
@@ -108,14 +115,14 @@ export function parseContainerBody(bodyText, wrap, opts) {
         last--;
         suffix = lines[last].raw;
     }
-    const inner = parseBlocks(lines, first, last, defaultGrammarView, opts.depth ?? 0, opts.scope === 'document');
+    const inner = parseBlocks(lines, first, last, opts);
     return { kind: 'document', prefix, children: inner.children, suffix: inner.suffix + suffix };
 }
 // ── Dispatch ────────────────────────────────────────────────────────────
 function parseNextBlock(ctx) {
-    // At the cap everything folds into a paragraph, covering the bytes without another frame.
+    // At the cap everything becomes a paragraph, covering the bytes without another stack frame.
     if (ctx.depth >= MAX_NESTING_DEPTH) {
-        return parseParagraph(ctx.lines, ctx.index, ctx.end, ctx.leadingTrivia);
+        return parseParagraph(ctx.lines, ctx.index, ctx.end, ctx.leadingTrivia, ctx.grammar);
     }
     for (const opener of ctx.grammar.orderedOpeners()) {
         const result = opener.tryOpen(ctx);
@@ -125,31 +132,25 @@ function parseNextBlock(ctx) {
             reportNonAdvancingOpener(ctx, result);
             continue;
         }
-        if (DEV)
+        if (isDevChecks())
             assertOpenerRawMatches(ctx, result);
         return result;
     }
     // Paragraph is the total fallback; it also detects setext headings and tables.
-    return parseParagraph(ctx.lines, ctx.index, ctx.end, ctx.leadingTrivia);
+    return parseParagraph(ctx.lines, ctx.index, ctx.end, ctx.leadingTrivia, ctx.grammar);
 }
-/**
- * The `[invariant:...]` fire behind the call site's decline. An opener that consumed nothing is
- * declined in every build, not just DEV: returning it would leave `index` put and spin the parse
- * loop forever, and declining is always safe because the paragraph fallback covers the line.
- */
+/** The dev warning behind the call site's decline. An opener that consumed nothing is declined in
+ *  every build, or it would spin the parse loop; the paragraph fallback covers the line. */
 function reportNonAdvancingOpener(ctx, result) {
     assertInvariant('opener-advance', () => ({
         code: 'opener-did-not-advance',
-        message: `block opener for kind "${result.node.kind}" claimed no line at ${ctx.index} and was ` +
-            `declined — an opener must consume at least one line (return consumed >= 1)`,
+        message: `block opener for kind "${result.node.kind}" claimed no line at ${ctx.index} and was declined:` +
+            ` an opener must consume at least one line (return consumed >= 1)`,
         detail: result.node.kind
     }));
 }
-/**
- * DEV-only trust check on a plugin opener's `raw`, at the one site the parser consumes it:
- * bytes that do not match the consumed lines silently break the round-trip, since serialize
- * reads `raw` alone. Tree-shaken in production.
- */
+/** Dev-only check that a plugin opener's `raw` matches the lines it consumed: serialize reads `raw`
+ *  alone, so a mismatch silently breaks the round-trip. */
 function assertOpenerRawMatches(ctx, result) {
     assertInvariant('opener-raw', () => result.node.raw === joinRaw(ctx.lines, ctx.index, ctx.index + result.consumed)
         ? null
@@ -161,24 +162,9 @@ function assertOpenerRawMatches(ctx, result) {
         });
 }
 // ── Shared utilities ────────────────────────────────────────────────────
-/**
- * GFM §2.1: a blank line holds nothing but spaces and tabs. Deliberately not `String.trim()`,
- * which admits all Unicode whitespace: a non-breaking space is content, and a line holding one
- * continues its block.
- */
-const NON_BLANK_CHAR = /[^ \t]/;
-export function isBlankLine(text) {
-    return !NON_BLANK_CHAR.test(text);
-}
-/**
- * Nothing but blank lines — what the blank-line rule mints a block from. Blankness is the
- * parser's (GFM §2.1), never `String.trim()`: a non-breaking space is content.
- */
-export function isBlankSource(source) {
-    return splitLines(source).every((line) => isBlankLine(line.text));
-}
+export { isBlankLine };
 export function isBlankParagraph(node) {
-    return node.kind === 'paragraph' && isBlankSource(node.raw);
+    return node.kind === 'paragraph' && isBlankText(node.raw);
 }
 export function joinRaw(lines, startIndex, endIndex) {
     let result = '';

package/dist/core/parsers/blockquote.d.ts

@@ -3,15 +3,12 @@
  * approximated per line (non-blank, not a block opener), not tracked as parser state.
  */
 import { type ParsedLine } from '../lines';
-import { type BlockOpenerResult } from '../../schema/block-openers';
+import { type BlockOpenerResult, type GrammarView } from '../../schema/block-openers';
 export declare function matchBlockquote(text: string): boolean;
-/**
- * Byte-exact `raw` of a blockquote's extent (CommonMark §5.1 lazy continuation) plus the
- * index past it, no child decomposition: what a blockquote-shaped opener needs when it
- * decomposes its own body (`> [!NOTE]` alerts strip the marker line before parsing children).
- */
-export declare function blockquoteExtent(lines: ParsedLine[], startIndex: number, endIndex: number): {
+/** Byte-exact `raw` of a blockquote's extent plus the index past it, with no child decomposition,
+ *  for an opener that decomposes its own body (`> [!NOTE]`). The grammar defaults to every plugin. */
+export declare function blockquoteExtent(lines: ParsedLine[], startIndex: number, endIndex: number, grammar?: GrammarView): {
     raw: string;
     nextIndex: number;
 };
-export declare function parseBlockquote(lines: ParsedLine[], startIndex: number, endIndex: number, leadingTrivia: string, depth?: number, isDocumentParse?: boolean): BlockOpenerResult;
+export declare function parseBlockquote(lines: ParsedLine[], startIndex: number, endIndex: number, leadingTrivia: string, grammar: GrammarView, depth?: number, isDocumentParse?: boolean): BlockOpenerResult;

package/dist/core/parsers/blockquote.js

@@ -21,12 +21,9 @@ function wouldKeepParagraphOpen(strippedText) {
         return false;
     return true;
 }
-/**
- * Byte-exact `raw` of a blockquote's extent (CommonMark §5.1 lazy continuation) plus the
- * index past it, no child decomposition: what a blockquote-shaped opener needs when it
- * decomposes its own body (`> [!NOTE]` alerts strip the marker line before parsing children).
- */
-export function blockquoteExtent(lines, startIndex, endIndex) {
+/** Byte-exact `raw` of a blockquote's extent plus the index past it, with no child decomposition,
+ *  for an opener that decomposes its own body (`> [!NOTE]`). The grammar defaults to every plugin. */
+export function blockquoteExtent(lines, startIndex, endIndex, grammar = defaultGrammarView) {
     let i = startIndex;
     let paragraphOpen = false;
     while (i < endIndex) {
@@ -39,7 +36,7 @@ export function blockquoteExtent(lines, startIndex, endIndex) {
         }
         if (paragraphOpen &&
             wouldKeepParagraphOpen(lineText) &&
-            !lineStartsOuterBlock(lines[i], { paragraphOpen: true })) {
+            !lineStartsOuterBlock(lines[i], { paragraphOpen: true, grammar })) {
             i++;
             continue;
         }
@@ -47,11 +44,15 @@ export function blockquoteExtent(lines, startIndex, endIndex) {
     }
     return { raw: joinRaw(lines, startIndex, i), nextIndex: i };
 }
-export function parseBlockquote(lines, startIndex, endIndex, leadingTrivia, depth = 0, isDocumentParse = false) {
-    const { raw, nextIndex: i } = blockquoteExtent(lines, startIndex, endIndex);
+export function parseBlockquote(lines, startIndex, endIndex, leadingTrivia, grammar, depth = 0, isDocumentParse = false) {
+    const { raw, nextIndex: i } = blockquoteExtent(lines, startIndex, endIndex, grammar);
     // Lazy lines have no `> ` to strip; verbatim keeps the recursive parse seeing one paragraph.
     const strippedLines = remapStrippedLines(lines.slice(startIndex, i), (line) => matchBlockquote(line.text) ? stripBlockquotePrefix(line.text) : line.text);
-    const inner = parseBlocks(strippedLines, 0, strippedLines.length, defaultGrammarView, depth + 1, isDocumentParse);
+    const inner = parseBlocks(strippedLines, 0, strippedLines.length, {
+        grammar,
+        scope: isDocumentParse ? 'document' : 'fragment',
+        depth: depth + 1
+    });
     const quotePrefix = lines[startIndex].text.match(/^ {0,3}(>[ \t]?)+/)[0];
     const quoteDepth = quotePrefix.match(/>/g).length;
     return {

package/dist/core/parsers/built-in-openers.d.ts

@@ -1,8 +1,5 @@
 /**
- * Registers the built-in block openers. Lives beside the matchers because
- * schema/block-kind-descriptor.ts importing them would cycle (parsers/* import
- * parser.ts, which reads the opener registry). Called explicitly from core/parser.ts: the
- * `sideEffects` allowlist names dist paths, never the src specifier used here, so a bare
- * side-effect import would be droppable.
+ * Registers the built-in block openers. Called explicitly from `core/parser.ts`, since a bare
+ * side-effect import would be tree-shaken from the production build.
  */
 export declare function registerBuiltInOpeners(): void;

package/dist/core/parsers/built-in-openers.js

@@ -1,9 +1,6 @@
 /**
- * Registers the built-in block openers. Lives beside the matchers because
- * schema/block-kind-descriptor.ts importing them would cycle (parsers/* import
- * parser.ts, which reads the opener registry). Called explicitly from core/parser.ts: the
- * `sideEffects` allowlist names dist paths, never the src specifier used here, so a bare
- * side-effect import would be droppable.
+ * Registers the built-in block openers. Called explicitly from `core/parser.ts`, since a bare
+ * side-effect import would be tree-shaken from the production build.
  */
 import { registerBlockOpener } from '../../schema/block-openers';
 import { OPENER_PRIORITIES } from '../../schema/opener-priorities';
@@ -17,7 +14,7 @@ import { matchIndentedCode, parseIndentedCode } from './indented-code';
 import { matchHtmlBlock, parseHtmlBlock, canInterruptParagraph as htmlCanInterrupt } from './html-block';
 import { parseLinkReferenceDefinition } from './link-reference';
 // Idempotence guard, not a registry bypass: a dev-server re-eval resets it so
-// the register-once dev valve still replaces.
+// the register-once dev path still replaces.
 let registered = false;
 export function registerBuiltInOpeners() {
     if (registered)
@@ -80,7 +77,7 @@ export function registerBuiltInOpeners() {
         tryOpen(ctx) {
             if (!matchBlockquote(ctx.line.text))
                 return null;
-            return parseBlockquote(ctx.lines, ctx.index, ctx.end, ctx.leadingTrivia, ctx.depth, ctx.isDocumentParse);
+            return parseBlockquote(ctx.lines, ctx.index, ctx.end, ctx.leadingTrivia, ctx.grammar, ctx.depth, ctx.isDocumentParse);
         },
         interruptsParagraph: matchBlockquote
     });
@@ -89,7 +86,7 @@ export function registerBuiltInOpeners() {
         tryOpen(ctx) {
             if (!matchListItem(ctx.line.text))
                 return null;
-            return parseList(ctx.lines, ctx.index, ctx.end, ctx.leadingTrivia, ctx.depth, ctx.isDocumentParse);
+            return parseList(ctx.lines, ctx.index, ctx.end, ctx.leadingTrivia, ctx.grammar, ctx.depth, ctx.isDocumentParse);
         },
         interruptsParagraph: listCanInterrupt
     });