@redocly/recheck 0.1.0 → 0.3.0

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":"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"}

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"}

package/dist/parser/markdoc/pairing.js

@@ -0,0 +1,94 @@
+/**
+ * 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 function emptyMarkdocPairing() {
+    return { pairs: [], unclosed: [], orphaned: [], crossed: [], voidMissingSlash: [] };
+}
+// Kinds that never enter the pairing stack: annotation, variable, and function
+// spans carry no tag name at all, a self-closing tag (`{% x /%}`) is already
+// complete on its own, and a malformed span is left inert so it cannot disturb
+// the pairing of the well-formed tags around it (the syntax-level rule owns
+// reporting it).
+const NEVER_PAIRED_KINDS = new Set([
+    'annotation',
+    'variable',
+    'function',
+    'tag-self-closing',
+    'malformed',
+]);
+/** The tag's own name, from its synthesized `markdocTagName` child (absent
+ * only for the kinds already filtered out above, where it's `null`). */
+function tagName(token) {
+    const nameChild = token.children.find((child) => child.type === 'markdocTagName');
+    return nameChild ? nameChild.text : null;
+}
+/**
+ * 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 function computeMarkdocPairing(tree, options = {}) {
+    const selfClosingTags = options.selfClosingTags ?? new Set();
+    const tags = tree.flat
+        .filter((token) => token.type === 'markdocTag')
+        .sort((a, b) => a.startLine - b.startLine || a.startColumn - b.startColumn);
+    const stack = [];
+    const pairs = [];
+    const crossed = [];
+    const orphaned = [];
+    for (const token of tags) {
+        const kind = token.markdocKind;
+        if (kind === undefined || NEVER_PAIRED_KINDS.has(kind))
+            continue;
+        const name = tagName(token);
+        if (name === null)
+            continue; // defensive only: every tag-open/tag-close carries a name
+        if (kind === 'tag-open') {
+            stack.push({ token, name, depth: stack.length, crossed: false });
+            continue;
+        }
+        // kind === 'tag-close': innermost-first search for the nearest same-name open.
+        let matchIndex = -1;
+        for (let i = stack.length - 1; i >= 0; i--) {
+            if (stack[i].name === name) {
+                matchIndex = i;
+                break;
+            }
+        }
+        if (matchIndex === -1) {
+            orphaned.push(token);
+            continue;
+        }
+        const jumpedOver = matchIndex !== stack.length - 1;
+        if (jumpedOver) {
+            for (let i = matchIndex + 1; i < stack.length; i++)
+                stack[i].crossed = true;
+        }
+        const [matched] = stack.splice(matchIndex, 1);
+        const pair = { open: matched.token, close: token, depth: matched.depth };
+        (jumpedOver || matched.crossed ? crossed : pairs).push(pair);
+    }
+    const unclosed = [];
+    const voidMissingSlash = [];
+    for (const entry of stack) {
+        (selfClosingTags.has(entry.name) ? voidMissingSlash : unclosed).push(entry.token);
+    }
+    return { pairs, unclosed, orphaned, crossed, voidMissingSlash };
+}
+//# sourceMappingURL=pairing.js.map

package/dist/parser/markdoc/pairing.js.map

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

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

@@ -0,0 +1,85 @@
+/**
+ * One attribute's statically-checkable facets. `type` is limited to the three
+ * JSON primitives recheck can compare a parsed literal against; anything richer
+ * upstream (objects, arrays, union types, custom attribute classes) has no
+ * faithful representative here and gets `dynamic: true` instead.
+ */
+export interface MarkdocAttributeSchema {
+    type: 'string' | 'number' | 'boolean';
+    required?: boolean;
+    default?: string | number | boolean;
+    /** Markdoc's `matches` array, renamed for recheck's own vocabulary. */
+    enum?: readonly string[];
+    /**
+     * Set when the upstream attribute's type isn't one of the three JSON
+     * primitives, or when the tag's schema carries a `validate()` function.
+     * Recheck's value-shape checks (type and enum) skip such an attribute rather
+     * than guess at business logic they cannot run. `required` is deliberately not
+     * skipped: upstream enforces it purely by presence, independently of `type`,
+     * `matches`, and `validate()`, even for a custom-class-typed attribute, so
+     * `markdoc-attributes` checks it unconditionally. The attribute's name is known
+     * either way, so unknown-attribute checks are unaffected.
+     */
+    dynamic?: boolean;
+}
+export interface MarkdocTagSchema {
+    selfClosing?: boolean;
+    attributes?: Record<string, MarkdocAttributeSchema>;
+}
+export interface MarkdocSchema {
+    tags: Record<string, MarkdocTagSchema>;
+}
+/**
+ * The object form of the `markdoc` config key. `schema` is required here: the
+ * boolean shorthand `true` unambiguously means `{ schema: 'realm' }`, but an
+ * object with `schema` omitted has no default this format defines, so
+ * `config/schema.ts` rejects it rather than guessing.
+ */
+export interface MarkdocUserConfig {
+    schema: 'realm' | false;
+    extend?: {
+        tags?: Record<string, MarkdocTagSchema>;
+        tagsFile?: string;
+    };
+}
+/**
+ * The already-loaded view of `extend` that `config/validate.ts` builds after
+ * reading and shape-checking `tagsFile` (if any): `fileTags` is that file's
+ * tags, `tags` is the config's own inline `extend.tags`. Kept as two separate
+ * fields, not pre-merged, so `mergeExtend` alone owns the precedence order.
+ */
+export interface ResolvedExtend {
+    fileTags?: Record<string, MarkdocTagSchema>;
+    tags?: Record<string, MarkdocTagSchema>;
+}
+/**
+ * Normalizes the raw `markdoc` config value (boolean shorthand or object form)
+ * into `{ enabled, schema }`. It is called from `config/validate.ts` after AJV
+ * structural validation, but the check order there means it still sees the raw
+ * value when validation failed, so it must never throw on a malformed shape
+ * (`{ schema: 'bogus' }`, a bare string): anything unrecognized normalizes to
+ * disabled.
+ *
+ * `schema: false` deliberately is not "fully off". Parsing and pairing still
+ * run, and only the schema-dependent rules (unknown tag, and the
+ * unknown/required/enum attribute checks) go inert for lack of anything to check
+ * against. `extend` alongside `schema: false` is accepted structurally but has
+ * no effect, since there is no base to merge over.
+ *
+ * `resolvedExtend`, when passed, is the caller's already-loaded view of
+ * `extend` (`tagsFile` read and shape-checked, see config/validate.ts) and
+ * takes over from `raw.extend` entirely -- this module never reads a
+ * `tagsFile` itself, so a caller that resolved one has strictly more
+ * information than `raw.extend` alone.
+ */
+export declare function resolveMarkdocConfig(raw: boolean | MarkdocUserConfig | undefined, resolvedExtend?: ResolvedExtend): {
+    enabled: boolean;
+    schema: MarkdocSchema | null;
+};
+/**
+ * Tag names a schema declares self-closing, in the plain `Set<string>` shape
+ * `pairing.ts` consumes so the pairing pass depends on none of this module's
+ * types.
+ */
+export declare function selfClosingTagNames(schema: MarkdocSchema): ReadonlySet<string>;
+//# sourceMappingURL=schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/parser/markdoc/schema.ts"],"names":[],"mappings":"AAWA;;;;;GAKG;AACH,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAC;IACtC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;IACpC,uEAAuE;IACvE,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB;;;;;;;;;OASG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,gBAAgB;IAC/B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAC;CACrD;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;CACxC;AAED;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,OAAO,GAAG,KAAK,CAAC;IAOxB,MAAM,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CACzE;AAED;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IAC5C,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;CACzC;AAsBD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,OAAO,GAAG,iBAAiB,GAAG,SAAS,EAC5C,cAAc,CAAC,EAAE,cAAc,GAC9B;IACD,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,aAAa,GAAG,IAAI,CAAC;CAC9B,CAoBA;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,aAAa,GAAG,WAAW,CAAC,MAAM,CAAC,CAM9E"}