@redocly/recheck 0.1.0 → 0.2.0

package/dist/metrics/statistics.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Plain-prose text statistics feeding the readability formulas in
+ * `formulas.ts`. This module is pure -- no rules/, core/runner, or config/
+ * imports, and no markdown parsing: callers (e.g. the `metric` assertion)
+ * extract a plain prose string out of markdown first.
+ */
+export interface TextStatistics {
+    words: number;
+    sentences: number;
+    syllables: number;
+    /** Letters + digits only -- excludes punctuation and whitespace. Used by the automated-readability and coleman-liau formulas. */
+    characters: number;
+    /**
+     * Words with 3+ syllables per the `countSyllables` heuristic below (no
+     * proper-noun or suffix carve-outs).
+     */
+    complexWords: number;
+}
+export declare function tokenizeWords(prose: string): string[];
+/**
+ * Computes word/sentence/syllable/character/complex-word statistics for a
+ * plain prose string. `sentences` is delegated to `scopes/sentences.ts`'s
+ * `splitSentences` so the whole codebase shares one sentence-boundary
+ * definition.
+ */
+export declare function computeTextStatistics(prose: string): TextStatistics;
+//# sourceMappingURL=statistics.d.ts.map

package/dist/metrics/statistics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"statistics.d.ts","sourceRoot":"","sources":["../../src/metrics/statistics.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,iIAAiI;IACjI,UAAU,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,YAAY,EAAE,MAAM,CAAC;CACtB;AAmBD,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAErD;AAgBD;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,CAcnE"}

package/dist/metrics/statistics.js

@@ -0,0 +1,56 @@
+import { splitSentences } from '../scopes/sentences.js';
+// A "word" is a maximal whitespace-delimited token containing at least one
+// ASCII letter or digit: punctuation-only tokens (a lone "--" or "...")
+// don't count, while hyphenated compounds ("well-known") and contractions
+// ("don't") count as ONE word each. Tokenization is ASCII-only throughout
+// this module (here, the syllable heuristic, and the `characters` count),
+// so scores are meaningful for English prose.
+//
+// Exported deliberately -- there are exactly two consumers, and they must
+// share one implementation: `computeTextStatistics` below (readability
+// formulas) and the `length` scope assertion's `unit: 'words'` measurement
+// (rules/scope/length.ts). If `length` grew its own word-counting regex,
+// its word counts could silently drift from `metric`'s (e.g. a Microsoft
+// preset rule capping alt text at N words would disagree with a readability
+// rule scoring the same text) -- a duplicate here would be a correctness
+// bug, not just repeated code, so this is a shared-utility export, not the
+// "new rule's only consumer" shape a reviewer should otherwise flag (see
+// task-6-resolutions.md item 4).
+export function tokenizeWords(prose) {
+    return prose.split(/\s+/).filter((token) => /[A-Za-z0-9]/.test(token));
+}
+// Syllable heuristic: count vowel groups (/[aeiouy]+/, lowercase); subtract
+// one for a silent trailing 'e' unless the word ends in 'le' ("table");
+// minimum of 1. The token is first reduced to lowercase letters, hyphens,
+// and apostrophes so attached punctuation ("make,") can't defeat the
+// trailing-e check; hyphens/apostrophes are kept because they act as real
+// syllable boundaries ("co-op" is 2 vowel groups, "coop" is 1).
+function countSyllables(word) {
+    const clean = word.toLowerCase().replace(/[^a-z'-]/g, '');
+    const groups = clean.match(/[aeiouy]+/g) ?? [];
+    let count = groups.length;
+    if (clean.endsWith('e') && !clean.endsWith('le'))
+        count -= 1;
+    return Math.max(1, count);
+}
+/**
+ * Computes word/sentence/syllable/character/complex-word statistics for a
+ * plain prose string. `sentences` is delegated to `scopes/sentences.ts`'s
+ * `splitSentences` so the whole codebase shares one sentence-boundary
+ * definition.
+ */
+export function computeTextStatistics(prose) {
+    const words = tokenizeWords(prose);
+    const sentences = splitSentences(prose).length;
+    const characters = (prose.match(/[A-Za-z0-9]/g) ?? []).length;
+    let syllables = 0;
+    let complexWords = 0;
+    for (const word of words) {
+        const count = countSyllables(word);
+        syllables += count;
+        if (count >= 3)
+            complexWords += 1;
+    }
+    return { words: words.length, sentences, syllables, characters, complexWords };
+}
+//# sourceMappingURL=statistics.js.map

package/dist/metrics/statistics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"statistics.js","sourceRoot":"","sources":["../../src/metrics/statistics.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAqBxD,2EAA2E;AAC3E,wEAAwE;AACxE,0EAA0E;AAC1E,0EAA0E;AAC1E,0EAA0E;AAC1E,8CAA8C;AAC9C,EAAE;AACF,0EAA0E;AAC1E,uEAAuE;AACvE,2EAA2E;AAC3E,yEAAyE;AACzE,yEAAyE;AACzE,4EAA4E;AAC5E,yEAAyE;AACzE,2EAA2E;AAC3E,yEAAyE;AACzE,iCAAiC;AACjC,MAAM,UAAU,aAAa,CAAC,KAAa;IACzC,OAAO,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;AACzE,CAAC;AAED,4EAA4E;AAC5E,wEAAwE;AACxE,0EAA0E;AAC1E,qEAAqE;AACrE,0EAA0E;AAC1E,gEAAgE;AAChE,SAAS,cAAc,CAAC,IAAY;IAClC,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC;IAC1D,MAAM,MAAM,GAAG,KAAK,CAAC,KAAK,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;IAC/C,IAAI,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC;IAC1B,IAAI,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC;QAAE,KAAK,IAAI,CAAC,CAAC;IAC7D,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;AAC5B,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,qBAAqB,CAAC,KAAa;IACjD,MAAM,KAAK,GAAG,aAAa,CAAC,KAAK,CAAC,CAAC;IACnC,MAAM,SAAS,GAAG,cAAc,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC;IAC/C,MAAM,UAAU,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,cAAc,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC;IAE9D,IAAI,SAAS,GAAG,CAAC,CAAC;IAClB,IAAI,YAAY,GAAG,CAAC,CAAC;IACrB,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,MAAM,KAAK,GAAG,cAAc,CAAC,IAAI,CAAC,CAAC;QACnC,SAAS,IAAI,KAAK,CAAC;QACnB,IAAI,KAAK,IAAI,CAAC;YAAE,YAAY,IAAI,CAAC,CAAC;IACpC,CAAC;IAED,OAAO,EAAE,KAAK,EAAE,KAAK,CAAC,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,UAAU,EAAE,YAAY,EAAE,CAAC;AACjF,CAAC"}

package/dist/parser/index.d.ts

@@ -0,0 +1,18 @@
+import type { Token, TokenTree } from './types.js';
+export type { Token, TokenTree } from './types.js';
+export interface ParseOptions {
+    markdoc?: boolean;
+}
+export declare function parseMarkdown(content: string, options?: ParseOptions): TokenTree;
+/**
+ * Filters the tree's flat token list by type. By default, tokens produced
+ * by reparsing an `htmlFlow` block (see `reparseHtmlFlow` above) are
+ * EXCLUDED -- matching upstream markdownlint's own `filterByTypes(tokens,
+ * types, htmlFlow)` helper, whose `htmlFlow` parameter defaults to falsy.
+ * Pass `includeHtmlFlow: true` for rules that explicitly want to see
+ * inside HTML blocks too (upstream's MD033/no-inline-html and
+ * MD045/no-alt-text opt in this way; see their recheck ports for the same
+ * opt-in).
+ */
+export declare function filterByTypes(tree: TokenTree, types: readonly string[], includeHtmlFlow?: boolean): Token[];
+//# sourceMappingURL=index.d.ts.map

package/dist/parser/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/parser/index.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAInD,YAAY,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AA8InD,MAAM,WAAW,YAAY;IAI3B,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,YAAiB,GAAG,SAAS,CAUpF;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,SAAS,EACf,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,eAAe,UAAQ,GACtB,KAAK,EAAE,CAIT"}

package/dist/parser/index.js

@@ -0,0 +1,168 @@
+// Micromark wrapper producing Recheck's public TokenTree.
+// Event-to-tree construction adapted from markdownlint's lib/micromark-parse.mjs
+// (https://github.com/DavidAnson/markdownlint, MIT © David Anson).
+import { parse, postprocess, preprocess } from 'micromark';
+import { directive } from 'micromark-extension-directive';
+import { frontmatter } from 'micromark-extension-frontmatter';
+import { gfmAutolinkLiteral } from 'micromark-extension-gfm-autolink-literal';
+import { gfmFootnote } from 'micromark-extension-gfm-footnote';
+import { gfmTable } from 'micromark-extension-gfm-table';
+import { math } from 'micromark-extension-math';
+import { markdocSyntax } from './markdoc/syntax.js';
+import { structureMarkdocTags } from './markdoc/structure.js';
+const baseExtensions = [
+    directive(),
+    gfmAutolinkLiteral(),
+    gfmFootnote(),
+    gfmTable(),
+    math(),
+    frontmatter(['yaml']),
+];
+// Forces htmlFlow (block HTML) regions to be reparsed as if they were
+// regular inline content -- disabling the `codeIndented`/`htmlFlow` block
+// constructs makes micromark fall through to paragraph/inline tokenization
+// for the same text, which is exactly what upstream markdownlint's own
+// `micromark-parse.mjs` shim does (it disables the identical pair) to
+// produce real `htmlText` tokens for tags inside HTML blocks. See
+// `reparseHtmlFlow` below.
+const htmlFlowReparseExtension = { disable: { null: ['codeIndented', 'htmlFlow'] } };
+function getEvents(content, extensions) {
+    const parseContext = parse({ extensions });
+    const chunks = preprocess()(content, undefined, true);
+    return postprocess(parseContext.document().write(chunks));
+}
+/**
+ * Builds a Token tree from a flat micromark event list. `lineOffset` and
+ * `firstLineColumnOffset` translate positions that are relative to
+ * `content` (starting at line 1, column 1) into the surrounding
+ * document's coordinate space -- used by `reparseHtmlFlow` below to splice
+ * a reparsed `htmlFlow` block's tokens back in at their real position.
+ * `content` itself must already be the exact document (or sub-region)
+ * text so `start.offset`/`end.offset` slicing stays correct.
+ */
+function buildTree(events, content, lineOffset = 0, firstLineColumnOffset = 0) {
+    const children = [];
+    const flat = [];
+    const stack = [];
+    const adjustLine = (line) => line + lineOffset;
+    const adjustColumn = (line, column) => line === 1 ? column + firstLineColumnOffset : column;
+    for (const event of events) {
+        const [kind, mmToken] = event;
+        if (kind === 'enter') {
+            const parent = stack[stack.length - 1] ?? null;
+            const token = {
+                type: mmToken.type,
+                startLine: adjustLine(mmToken.start.line),
+                startColumn: adjustColumn(mmToken.start.line, mmToken.start.column),
+                endLine: adjustLine(mmToken.end.line),
+                endColumn: adjustColumn(mmToken.end.line, mmToken.end.column),
+                text: '',
+                children: [],
+                parent,
+            };
+            (parent ? parent.children : children).push(token);
+            flat.push(token);
+            stack.push(token);
+        }
+        else {
+            const token = stack.pop();
+            if (token) {
+                // Slice from the original content via absolute offsets rather than
+                // `context.sliceSerialize`. Nested/subtokenized content (e.g. list
+                // items containing sublists) can leave an exit event's `context`
+                // pointing at a tokenizer buffer that no longer covers this token,
+                // crashing `sliceSerialize`. `start.offset`/`end.offset` are stable
+                // document-absolute positions, so slicing `content` directly avoids
+                // depending on which context object emitted the event, matching
+                // markdownlint's lib/micromark-parse.mjs `getText` helper (MIT).
+                token.text = content.slice(mmToken.start.offset, mmToken.end.offset);
+                token.endLine = adjustLine(mmToken.end.line);
+                token.endColumn = adjustColumn(mmToken.end.line, mmToken.end.column);
+            }
+        }
+    }
+    return { children, flat };
+}
+/**
+ * Returns true iff the token is an HTML comment (`<!-- ... -->`) that is
+ * valid per the CommonMark spec. Duplicated (narrowly) from
+ * rules/token/helpers.ts's `isHtmlFlowComment` rather than imported --
+ * that module is rule-layer code that itself depends on parser types, and
+ * this parser module must not depend back on the rules layer.
+ */
+function isHtmlFlowComment(token) {
+    const { text, type } = token;
+    if (type === 'htmlFlow' && text.startsWith('<!--') && text.endsWith('-->')) {
+        const comment = text.slice(4, -3);
+        return !comment.startsWith('>') && !comment.startsWith('->') && !comment.endsWith('-');
+    }
+    return false;
+}
+/**
+ * Re-tokenizes every non-comment `htmlFlow` (block HTML) token's own text
+ * as inline content, splicing the result in as that token's children (and
+ * into `flat`) so rules that look for `htmlText` tokens (e.g. MD033
+ * no-inline-html) see tags inside HTML blocks -- not just genuinely
+ * inline HTML -- exactly like upstream markdownlint (see
+ * `htmlFlowReparseExtension`'s doc comment). Mutates `tree.flat` in place;
+ * `tree.children` already references the same token objects, so no
+ * further mutation is needed there.
+ *
+ * A block like:
+ *   <details>
+ *   <summary>Text</summary>
+ * is ONE `htmlFlow` token whose raw text spans both lines; reparsing it
+ * with `codeIndented`/`htmlFlow` disabled naturally produces `htmlText`
+ * tokens for `<details>`, `<summary>`, and `</summary>` as descendants,
+ * which is what makes the fix work even when multiple tags/lines are
+ * inside a single flow block.
+ */
+function reparseHtmlFlow(tree) {
+    const htmlFlowTokens = tree.flat.filter((token) => token.type === 'htmlFlow' && !isHtmlFlowComment(token));
+    for (const token of htmlFlowTokens) {
+        const events = getEvents(token.text, [...baseExtensions, htmlFlowReparseExtension]);
+        const reparsed = buildTree(events, token.text, token.startLine - 1, token.startColumn - 1);
+        // Re-parent every reparsed token onto the original htmlFlow token, mark
+        // it `inHtmlFlow` (see Token's doc comment -- lets `filterByTypes`
+        // exclude this synthetic content by default, matching upstream), and
+        // add them all to the shared flat list. The htmlFlow token's OWN
+        // top-level type/text/position are left untouched -- only its
+        // (previously empty-of-inline-tags) children are replaced.
+        for (const descendant of reparsed.flat)
+            descendant.inHtmlFlow = true;
+        for (const child of reparsed.children)
+            child.parent = token;
+        token.children = reparsed.children;
+        // Push one-by-one: spreading an unbounded array as arguments overflows
+        // the call stack on huge HTML blocks (tens of thousands of lines), and
+        // this pass must never throw on a large document.
+        for (const descendant of reparsed.flat)
+            tree.flat.push(descendant);
+    }
+}
+export function parseMarkdown(content, options = {}) {
+    // With the flag off, the extension list and the post-passes are identical to
+    // a parse that knows nothing about Markdoc -- `markdocSyntax()` is never even
+    // instantiated -- so the tree stays byte-identical by construction.
+    const extensions = options.markdoc ? [...baseExtensions, markdocSyntax(content)] : baseExtensions;
+    const events = getEvents(content, extensions);
+    const tree = buildTree(events, content);
+    reparseHtmlFlow(tree);
+    if (options.markdoc)
+        structureMarkdocTags(tree);
+    return tree;
+}
+/**
+ * Filters the tree's flat token list by type. By default, tokens produced
+ * by reparsing an `htmlFlow` block (see `reparseHtmlFlow` above) are
+ * EXCLUDED -- matching upstream markdownlint's own `filterByTypes(tokens,
+ * types, htmlFlow)` helper, whose `htmlFlow` parameter defaults to falsy.
+ * Pass `includeHtmlFlow: true` for rules that explicitly want to see
+ * inside HTML blocks too (upstream's MD033/no-inline-html and
+ * MD045/no-alt-text opt in this way; see their recheck ports for the same
+ * opt-in).
+ */
+export function filterByTypes(tree, types, includeHtmlFlow = false) {
+    return tree.flat.filter((token) => types.includes(token.type) && (includeHtmlFlow || !token.inHtmlFlow));
+}
+//# sourceMappingURL=index.js.map

package/dist/parser/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/parser/index.ts"],"names":[],"mappings":"AAAA,0DAA0D;AAC1D,iFAAiF;AACjF,mEAAmE;AACnE,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC3D,OAAO,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAC;AAC1D,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAC9D,OAAO,EAAE,kBAAkB,EAAE,MAAM,0CAA0C,CAAC;AAC9E,OAAO,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAC/D,OAAO,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AACzD,OAAO,EAAE,IAAI,EAAE,MAAM,0BAA0B,CAAC;AAIhD,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAI9D,MAAM,cAAc,GAAG;IACrB,SAAS,EAAE;IACX,kBAAkB,EAAE;IACpB,WAAW,EAAE;IACb,QAAQ,EAAE;IACV,IAAI,EAAE;IACN,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;CACtB,CAAC;AAEF,sEAAsE;AACtE,0EAA0E;AAC1E,2EAA2E;AAC3E,uEAAuE;AACvE,sEAAsE;AACtE,kEAAkE;AAClE,2BAA2B;AAC3B,MAAM,wBAAwB,GAAc,EAAE,OAAO,EAAE,EAAE,IAAI,EAAE,CAAC,cAAc,EAAE,UAAU,CAAC,EAAE,EAAE,CAAC;AAEhG,SAAS,SAAS,CAAC,OAAe,EAAE,UAAuB;IACzD,MAAM,YAAY,GAAG,KAAK,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC;IAC3C,MAAM,MAAM,GAAG,UAAU,EAAE,CAAC,OAAO,EAAE,SAAS,EAAE,IAAI,CAAC,CAAC;IACtD,OAAO,WAAW,CAAC,YAAY,CAAC,QAAQ,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC;AAC5D,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,SAAS,CAChB,MAAe,EACf,OAAe,EACf,UAAU,GAAG,CAAC,EACd,qBAAqB,GAAG,CAAC;IAEzB,MAAM,QAAQ,GAAY,EAAE,CAAC;IAC7B,MAAM,IAAI,GAAY,EAAE,CAAC;IACzB,MAAM,KAAK,GAAY,EAAE,CAAC;IAC1B,MAAM,UAAU,GAAG,CAAC,IAAY,EAAE,EAAE,CAAC,IAAI,GAAG,UAAU,CAAC;IACvD,MAAM,YAAY,GAAG,CAAC,IAAY,EAAE,MAAc,EAAE,EAAE,CACpD,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,GAAG,qBAAqB,CAAC,CAAC,CAAC,MAAM,CAAC;IACvD,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,GAAG,KAAK,CAAC;QAC9B,IAAI,IAAI,KAAK,OAAO,EAAE,CAAC;YACrB,MAAM,MAAM,GAAG,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,IAAI,IAAI,CAAC;YAC/C,MAAM,KAAK,GAAU;gBACnB,IAAI,EAAE,OAAO,CAAC,IAAI;gBAClB,SAAS,EAAE,UAAU,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC;gBACzC,WAAW,EAAE,YAAY,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,EAAE,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC;gBACnE,OAAO,EAAE,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC;gBACrC,SAAS,EAAE,YAAY,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC;gBAC7D,IAAI,EAAE,EAAE;gBACR,QAAQ,EAAE,EAAE;gBACZ,MAAM;aACP,CAAC;YACF,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAClD,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACjB,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACpB,CAAC;aAAM,CAAC;YACN,MAAM,KAAK,GAAG,KAAK,CAAC,GAAG,EAAE,CAAC;YAC1B,IAAI,KAAK,EAAE,CAAC;gBACV,mEAAmE;gBACnE,mEAAmE;gBACnE,iEAAiE;gBACjE,mEAAmE;gBACnE,oEAAoE;gBACpE,oEAAoE;gBACpE,gEAAgE;gBAChE,iEAAiE;gBACjE,KAAK,CAAC,IAAI,GAAG,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;gBACrE,KAAK,CAAC,OAAO,GAAG,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;gBAC7C,KAAK,CAAC,SAAS,GAAG,YAAY,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;YACvE,CAAC;QACH,CAAC;IACH,CAAC;IACD,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;AAC5B,CAAC;AAED;;;;;;GAMG;AACH,SAAS,iBAAiB,CAAC,KAAY;IACrC,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,KAAK,CAAC;IAC7B,IAAI,IAAI,KAAK,UAAU,IAAI,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;QAC3E,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QAClC,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;IACzF,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,SAAS,eAAe,CAAC,IAAe;IACtC,MAAM,cAAc,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,CACrC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,KAAK,UAAU,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAClE,CAAC;IACF,KAAK,MAAM,KAAK,IAAI,cAAc,EAAE,CAAC;QACnC,MAAM,MAAM,GAAG,SAAS,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,GAAG,cAAc,EAAE,wBAAwB,CAAC,CAAC,CAAC;QACpF,MAAM,QAAQ,GAAG,SAAS,CAAC,MAAM,EAAE,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,SAAS,GAAG,CAAC,EAAE,KAAK,CAAC,WAAW,GAAG,CAAC,CAAC,CAAC;QAC3F,wEAAwE;QACxE,mEAAmE;QACnE,qEAAqE;QACrE,iEAAiE;QACjE,8DAA8D;QAC9D,2DAA2D;QAC3D,KAAK,MAAM,UAAU,IAAI,QAAQ,CAAC,IAAI;YAAE,UAAU,CAAC,UAAU,GAAG,IAAI,CAAC;QACrE,KAAK,MAAM,KAAK,IAAI,QAAQ,CAAC,QAAQ;YAAE,KAAK,CAAC,MAAM,GAAG,KAAK,CAAC;QAC5D,KAAK,CAAC,QAAQ,GAAG,QAAQ,CAAC,QAAQ,CAAC;QACnC,uEAAuE;QACvE,uEAAuE;QACvE,kDAAkD;QAClD,KAAK,MAAM,UAAU,IAAI,QAAQ,CAAC,IAAI;YAAE,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IACrE,CAAC;AACH,CAAC;AASD,MAAM,UAAU,aAAa,CAAC,OAAe,EAAE,OAAO,GAAiB,EAAE;IACvE,6EAA6E;IAC7E,8EAA8E;IAC9E,oEAAoE;IACpE,MAAM,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,cAAc,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC;IAClG,MAAM,MAAM,GAAG,SAAS,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;IAC9C,MAAM,IAAI,GAAG,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACxC,eAAe,CAAC,IAAI,CAAC,CAAC;IACtB,IAAI,OAAO,CAAC,OAAO;QAAE,oBAAoB,CAAC,IAAI,CAAC,CAAC;IAChD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,aAAa,CAC3B,IAAe,EACf,KAAwB,EACxB,eAAe,GAAG,KAAK;IAEvB,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CACrB,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,eAAe,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CAChF,CAAC;AACJ,CAAC"}

package/dist/parser/markdoc/extract-statics.d.ts

@@ -0,0 +1,45 @@
+import type { MarkdocAttributeSchema, MarkdocSchema } from './schema.js';
+/** Enough of a real Markdoc `Config['tags'][name]['attributes'][name]` entry to extract statics from. */
+export interface RawMarkdocAttribute {
+    type?: unknown;
+    required?: boolean;
+    default?: unknown;
+    matches?: unknown;
+}
+/** Enough of a real Markdoc `Config['tags'][name]` entry to extract statics from. */
+export interface RawMarkdocTag {
+    selfClosing?: boolean;
+    attributes?: Record<string, RawMarkdocAttribute>;
+    validate?: unknown;
+}
+export type RawMarkdocTagMap = Record<string, RawMarkdocTag>;
+/**
+ * Converts one raw Markdoc attribute definition into recheck's
+ * `MarkdocAttributeSchema`.
+ *
+ * `tagHasValidate` forces `dynamic: true` regardless of this attribute's own
+ * type. A tag-level `validate()` -- for example `img`'s src/srcSet/images
+ * mutual-exclusivity check, `code-snippet`'s from/after and to/before checks,
+ * or `diagram`'s type/align re-checks -- can read and reject any of the tag's
+ * attributes for reasons this generator can't discover from the schema object
+ * alone, since that would mean analyzing an arbitrary JS function body. So
+ * every attribute of a `validate()`-carrying tag is conservatively marked
+ * dynamic, even one with a plain `String`/`Number`/`Boolean` type and a
+ * `matches` array (`img.align`, `diagram.type`).
+ *
+ * Recorded facets (`required`, `default`, `enum`) are kept even when dynamic:
+ * `dynamic` only tells a value-checking rule to skip them, it doesn't make the
+ * facet itself unknown.
+ */
+export declare function extractAttribute(rawAttribute: RawMarkdocAttribute, tagHasValidate: boolean): MarkdocAttributeSchema;
+/**
+ * Composes three raw Markdoc tag maps in caller-chosen precedence order
+ * (later arguments win a name collision) and converts every tag to recheck's
+ * statics-only `MarkdocSchema`. Both callers share this precedence-then-convert
+ * shape: the built-in generator composes markdoc + portal + theme in Realm's
+ * own override order; the `recheck markdoc-schema` command extracts one
+ * project module's tags at a time and passes empty maps for the other two, so
+ * the composition is a no-op and only that module's tags come out.
+ */
+export declare function extractStatics(themeTagMap: RawMarkdocTagMap, markdocBuiltinTags: RawMarkdocTagMap, portalBuiltInTagMap: RawMarkdocTagMap): MarkdocSchema;
+//# sourceMappingURL=extract-statics.d.ts.map

package/dist/parser/markdoc/extract-statics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract-statics.d.ts","sourceRoot":"","sources":["../../../src/parser/markdoc/extract-statics.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EAAE,sBAAsB,EAAoB,aAAa,EAAE,MAAM,aAAa,CAAC;AAE3F,yGAAyG;AACzG,MAAM,WAAW,mBAAmB;IAClC,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,qFAAqF;AACrF,MAAM,WAAW,aAAa;IAC5B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;IACjD,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;AAe7D;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,gBAAgB,CAC9B,YAAY,EAAE,mBAAmB,EACjC,cAAc,EAAE,OAAO,GACtB,sBAAsB,CAoDxB;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAC5B,WAAW,EAAE,gBAAgB,EAC7B,kBAAkB,EAAE,gBAAgB,EACpC,mBAAmB,EAAE,gBAAgB,GACpC,aAAa,CA+Bf"}

package/dist/parser/markdoc/extract-statics.js

@@ -0,0 +1,139 @@
+// The single implementation of "a real Markdoc tag map -> recheck's
+// statics-only MarkdocSchema". Two callers share it and must never define
+// "what counts as a static facet" two different ways:
+//   - `scripts/generate-markdoc-schema.mjs`, which resolves Realm's composed
+//     built-in schema (markdoc + portal + theme) for the committed
+//     `src/data/markdoc-realm-schema.ts`, and re-exports these functions
+//     unchanged so its own drift test keeps working.
+//   - `src/commands/markdoc-schema.ts`, the `recheck markdoc-schema` CLI
+//     command, which extracts statics from a project's own schema module(s).
+//
+// Lives under `src/` (not `scripts/`) so the built CLI can import it at
+// runtime: `scripts/`'s own generator imports `@redocly/theme` and
+// `@redocly/portal`, both devDependencies-only, and this module must stay
+// free of any such import so requiring it from a published package never
+// drags those in.
+//
+// Raw tag/attribute shapes are typed loosely here rather than imported from
+// `@markdoc/markdoc` (also a devDependency-only): this module's declaration
+// file ships with the published package, and a type-only import still leaves
+// a reference downstream consumers' own type-checking would need
+// `@markdoc/markdoc` installed to resolve.
+// The three attribute-type constructors recheck's own format can represent
+// (see MarkdocAttributeSchema's doc comment in ./schema.ts). Every other
+// upstream type -- `Object`, `Array`, a union like `[String, Number]`, a
+// custom class implementing `CustomAttributeTypeInterface` (`RelativePath`,
+// `PartialFile`, ...), or no `type` at all (`debug`'s bare `{ value: {} }`) --
+// has no faithful single-primitive representative, so it's recorded
+// `dynamic: true` instead of guessing.
+const PRIMITIVE_TYPE_NAMES = new Map([
+    [String, 'string'],
+    [Number, 'number'],
+    [Boolean, 'boolean'],
+]);
+/**
+ * Converts one raw Markdoc attribute definition into recheck's
+ * `MarkdocAttributeSchema`.
+ *
+ * `tagHasValidate` forces `dynamic: true` regardless of this attribute's own
+ * type. A tag-level `validate()` -- for example `img`'s src/srcSet/images
+ * mutual-exclusivity check, `code-snippet`'s from/after and to/before checks,
+ * or `diagram`'s type/align re-checks -- can read and reject any of the tag's
+ * attributes for reasons this generator can't discover from the schema object
+ * alone, since that would mean analyzing an arbitrary JS function body. So
+ * every attribute of a `validate()`-carrying tag is conservatively marked
+ * dynamic, even one with a plain `String`/`Number`/`Boolean` type and a
+ * `matches` array (`img.align`, `diagram.type`).
+ *
+ * Recorded facets (`required`, `default`, `enum`) are kept even when dynamic:
+ * `dynamic` only tells a value-checking rule to skip them, it doesn't make the
+ * facet itself unknown.
+ */
+export function extractAttribute(rawAttribute, tagHasValidate) {
+    const rawType = rawAttribute.type;
+    const primitiveName = typeof rawType === 'function' ? PRIMITIVE_TYPE_NAMES.get(rawType) : undefined;
+    // `type` is non-optional in MarkdocAttributeSchema, and 'string' is the
+    // placeholder for anything non-primitive. It's a faithful placeholder
+    // rather than an arbitrary one: every custom attribute type in
+    // packages/theme (RelativePath, PartialFile, CodeSnippetFile, ...)
+    // implements `validate(value: string)`, so the wire value is always a
+    // string even when the class does extra work with it. A dynamic attribute
+    // is never value-checked anyway -- only the presence of `type` satisfies
+    // the interface.
+    const out = { type: primitiveName ?? 'string' };
+    if (rawAttribute.required === true)
+        out.required = true;
+    // `MarkdocAttributeSchema.default` can only hold a JSON primitive, and some
+    // defaults aren't one: `connect-mcp`'s `options` attribute defaults to an
+    // array (`['cursor', 'vscode', 'copy']`), which the interface has no slot
+    // for. Recording it would produce a schema that doesn't type-check against
+    // its own interface, so drop it rather than guess a representation.
+    // Nothing is lost: a non-primitive default always pairs with a
+    // non-primitive `type`, so the attribute is already `dynamic: true` and no
+    // value check reads its default.
+    const defaultType = typeof rawAttribute.default;
+    if (defaultType === 'string' || defaultType === 'number' || defaultType === 'boolean') {
+        out.default = rawAttribute.default;
+    }
+    // Markdoc's `matches` isn't always an array -- it can also be a RegExp or a
+    // predicate function -- and even when it is an array, its entries aren't
+    // guaranteed to be strings. `MarkdocAttributeSchema.enum` is
+    // `readonly string[]`, so:
+    //   - A non-array `matches` can't be represented as an enum at all, so it
+    //     falls back to `dynamic: true` like a class-typed attribute or a
+    //     `validate()`-carrying tag. Don't guess at a constraint this can't
+    //     statically resolve.
+    //   - An array `matches` with non-string entries is representable, just not
+    //     verbatim, so coerce it with `String(...)` rather than marking it
+    //     dynamic. The enum value check compares a parsed attribute literal's
+    //     source text against the declared enum -- a string comparison either
+    //     way -- so a coerced `'1'`/`'true'` is exactly what it needs.
+    if (rawAttribute.matches !== undefined) {
+        if (Array.isArray(rawAttribute.matches)) {
+            if (rawAttribute.matches.length > 0) {
+                out.enum = rawAttribute.matches.map((value) => String(value));
+            }
+        }
+        else {
+            out.dynamic = true;
+        }
+    }
+    if (primitiveName === undefined || tagHasValidate)
+        out.dynamic = true;
+    return out;
+}
+/**
+ * Composes three raw Markdoc tag maps in caller-chosen precedence order
+ * (later arguments win a name collision) and converts every tag to recheck's
+ * statics-only `MarkdocSchema`. Both callers share this precedence-then-convert
+ * shape: the built-in generator composes markdoc + portal + theme in Realm's
+ * own override order; the `recheck markdoc-schema` command extracts one
+ * project module's tags at a time and passes empty maps for the other two, so
+ * the composition is a no-op and only that module's tags come out.
+ */
+export function extractStatics(themeTagMap, markdocBuiltinTags, portalBuiltInTagMap) {
+    const composed = { ...markdocBuiltinTags, ...portalBuiltInTagMap, ...themeTagMap };
+    const tagNames = Object.keys(composed).sort();
+    const tags = {};
+    for (const tagName of tagNames) {
+        const rawSchema = composed[tagName];
+        const tagHasValidate = typeof rawSchema.validate === 'function';
+        const tagOut = {};
+        if (rawSchema.selfClosing === true)
+            tagOut.selfClosing = true;
+        const rawAttributes = rawSchema.attributes;
+        if (rawAttributes) {
+            const attributeNames = Object.keys(rawAttributes).sort();
+            if (attributeNames.length > 0) {
+                const attributesOut = {};
+                for (const attributeName of attributeNames) {
+                    attributesOut[attributeName] = extractAttribute(rawAttributes[attributeName], tagHasValidate);
+                }
+                tagOut.attributes = attributesOut;
+            }
+        }
+        tags[tagName] = tagOut;
+    }
+    return { tags };
+}
+//# sourceMappingURL=extract-statics.js.map

package/dist/parser/markdoc/extract-statics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract-statics.js","sourceRoot":"","sources":["../../../src/parser/markdoc/extract-statics.ts"],"names":[],"mappings":"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"}

package/dist/parser/markdoc/pairing.d.ts

@@ -0,0 +1,63 @@
+import type { Token, TokenTree } from '../types.js';
+export interface MarkdocPair {
+    open: Token;
+    close: Token;
+    /**
+     * Nesting depth of `open` at the moment it was pushed: 0 for a top-level tag,
+     * 1 for a tag opened inside exactly one other, and so on. It stays fixed even
+     * when `close` jumps over an intervening unmatched open (see `crossed`), since
+     * it describes where `open` appeared, not where its match landed.
+     */
+    depth: number;
+}
+/**
+ * The five buckets are disjoint: a pair lands in `pairs` or `crossed` but never
+ * both, and a token appears in at most one bucket.
+ */
+export interface MarkdocPairing {
+    /** Cleanly matched open/close pairs (no crossing involved on either side). */
+    pairs: MarkdocPair[];
+    /** Opens with no close by EOF (excluding schema-known void tags, below). */
+    unclosed: Token[];
+    /** Closes that match no open anywhere on the stack. */
+    orphaned: Token[];
+    /** Matched pairs whose open or close jumped, or was jumped by, another pair. */
+    crossed: MarkdocPair[];
+    /** Opens whose name is schema-declared self-closing, written without `/%}`. */
+    voidMissingSlash: Token[];
+}
+/**
+ * A "nothing was paired" result for callers that must still supply a
+ * `MarkdocPairing` but have no reason to run the pass -- the runner uses it when
+ * the Markdoc flag is on but no active rule can read the buckets anyway. A
+ * factory rather than a shared constant, because the buckets are mutable arrays
+ * and one shared instance would let an accidental push leak across files.
+ */
+export declare function emptyMarkdocPairing(): MarkdocPairing;
+export interface PairingOptions {
+    /**
+     * Tag names a schema declares self-closing. A plain `Set<string>` rather than
+     * a dependency on the schema module, so the schema's shape can change without
+     * this pass knowing anything beyond which names never take a close tag.
+     */
+    selfClosingTags?: ReadonlySet<string>;
+}
+/**
+ * Computes open/close pairing for a document's `markdocTag` tokens with a single
+ * stack walk in document order. The filtered list is sorted by position rather
+ * than trusting whatever order `tree.flat` happens to be in, since
+ * `structureMarkdocTags` (structure.ts) appends its own synthesized children to
+ * the end of that same array.
+ *
+ * Deliberate divergence from upstream Markdoc, which tests a close only against
+ * the immediate top of its stack and never searches deeper: for
+ * `{% a %}{% b %}{% /a %}{% /b %}` upstream reports a missing-closing plus a
+ * missing-opening and lets `a`'s node swallow everything to EOF, while this pass
+ * searches the whole stack innermost-first and reports both pairs as `crossed`.
+ * "These two pairs are interleaved" is the more actionable diagnostic, and a
+ * crossing can never silently land in `pairs`, so no error upstream reports is
+ * lost. The cost is that consumers relying on pair ranges see a narrower range
+ * for a crossed `open` than upstream's AST would give.
+ */
+export declare function computeMarkdocPairing(tree: TokenTree, options?: PairingOptions): MarkdocPairing;
+//# sourceMappingURL=pairing.d.ts.map

package/dist/parser/markdoc/pairing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pairing.d.ts","sourceRoot":"","sources":["../../../src/parser/markdoc/pairing.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAGpD,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,KAAK,CAAC;IACZ,KAAK,EAAE,KAAK,CAAC;IACb;;;;;OAKG;IACH,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,8EAA8E;IAC9E,KAAK,EAAE,WAAW,EAAE,CAAC;IACrB,4EAA4E;IAC5E,QAAQ,EAAE,KAAK,EAAE,CAAC;IAClB,uDAAuD;IACvD,QAAQ,EAAE,KAAK,EAAE,CAAC;IAClB,gFAAgF;IAChF,OAAO,EAAE,WAAW,EAAE,CAAC;IACvB,+EAA+E;IAC/E,gBAAgB,EAAE,KAAK,EAAE,CAAC;CAC3B;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,IAAI,cAAc,CAEpD;AAED,MAAM,WAAW,cAAc;IAC7B;;;;OAIG;IACH,eAAe,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CACvC;AAmCD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,SAAS,EACf,OAAO,GAAE,cAAmB,GAC3B,cAAc,CAsDhB"}