@redocly/recheck 0.1.0 → 0.3.0

package/dist/rules/token/markdoc-attributes.js

@@ -0,0 +1,269 @@
+// Schema-aware attribute validation for tags `markdoc-unknown-tag` already
+// accepts as known (that rule owns the tag NAME itself). Detection-only.
+// Re-parses each tag's text via `parseMarkdocSpan` because the child tokens
+// structure.ts synthesizes carry positions but no `valueKind`/`value`/
+// `dynamic` data.
+//
+// Only `tag-open`/`tag-self-closing` kinds are checked: close tags carry no
+// attributes in Markdoc's grammar, and annotation/variable/function/malformed
+// spans have no tag name to look up a schema with. Annotations are a known v1
+// gap -- real Markdoc does check their attributes against the node they attach
+// to, but no per-annotation schema is modeled here. Unknown tags are skipped
+// too: upstream reports `tag-undefined` and no attribute errors for them, so
+// adding attribute reports on top of `markdoc-unknown-tag`'s would be noise.
+import { parseMarkdocSpan, } from '../../parser/markdoc/span.js';
+import { filterByTypes } from '../../parser/index.js';
+/**
+ * Real Markdoc merges `{ ...globalAttributes, ...schema.attributes }` before
+ * validating, so `class`/`id` are never unknown -- but a tag that declares one
+ * itself wins that merge and has it value-checked like any other attribute
+ * (four realm tags declare their own `id`: `input`, `step`, `tabs`, `toggle`).
+ * The carve-out below therefore fires only when the tag's own schema has no
+ * entry for the name, which is also why `.x`/`#x` shortcuts are always
+ * schema-valid. The global case can't be value-checked at all: Markdoc's
+ * `Class`/`Id` validators are custom classes, out of reach for a
+ * statics-only schema -- see `MarkdocAttributeSchema`'s `dynamic` comment.
+ */
+const GLOBAL_ATTRIBUTE_NAMES = new Set(['class', 'id']);
+function describeValueKind(kind) {
+    if (kind === 'null')
+        return 'null';
+    const article = 'aeiou'.includes(kind[0]) ? 'an' : 'a';
+    return `${article} ${kind}`;
+}
+function formatEnum(values) {
+    return values.map((value) => `"${value}"`).join(', ');
+}
+/**
+ * Type + enum ("matches") checks for one already-known, non-dynamic,
+ * non-opaque attribute value -- shared by named attributes and the positional
+ * primary, which real Markdoc validates identically. Upstream treats the two
+ * checks as independent (a wrong-type value that also fails `matches` reports
+ * both), so this pushes up to two reports rather than short-circuiting.
+ */
+function checkValue(attrName, valueKind, value, attrSchema, position, reports) {
+    if (valueKind !== attrSchema.type) {
+        reports.push({
+            line: position.startLine,
+            column: position.startColumn,
+            context: `"${attrName}" must be a ${attrSchema.type} value — got ${describeValueKind(valueKind)}`,
+        });
+    }
+    if (attrSchema.enum && !attrSchema.enum.includes(String(value))) {
+        reports.push({
+            line: position.startLine,
+            column: position.startColumn,
+            context: `"${attrName}" must be one of ${formatEnum(attrSchema.enum)} — got "${String(value)}"`,
+        });
+    }
+}
+/** Value kinds this rule cannot statically check: `variable`/`function` are
+ * opaque at parse time, and `bareword` is already `markdoc-syntax`'s report --
+ * a type/enum verdict on a value that isn't legal Markdoc would contradict
+ * that rule's "quote the value" advice. */
+function isOpaqueOrSyntaxOwned(kind) {
+    return kind === 'variable' || kind === 'function' || kind === 'bareword';
+}
+export const markdocAttributes = {
+    name: 'markdoc-attributes',
+    tags: ['markdoc'],
+    fixable: false,
+    // Bare placeholder: every `onError` call supplies the complete sentence
+    // via `context`.
+    defaults: {
+        message: '%s',
+    },
+    check(ctx) {
+        if (!ctx.markdoc)
+            return; // flag off -- no markdocTag tokens exist at all
+        const { schema } = ctx.markdoc;
+        if (!schema)
+            return; // `schema: false` -- nothing to validate attributes against
+        // One tag can produce reports from four independent checks (primary,
+        // per-attribute, missing-required, duplicate) run in whatever order is
+        // convenient to compute, so reports are collected and sorted at the end
+        // to leave this rule in document order rather than check order.
+        const reports = [];
+        for (const token of filterByTypes(ctx.tree, ['markdocTag'])) {
+            if (token.markdocKind !== 'tag-open' && token.markdocKind !== 'tag-self-closing')
+                continue;
+            const nameChild = token.children.find((child) => child.type === 'markdocTagName');
+            const tagName = nameChild?.text;
+            if (!tagName)
+                continue; // defensive only: both kinds always carry a name child
+            const tagSchema = schema.tags[tagName];
+            if (!tagSchema)
+                continue; // unknown tag -- markdoc-unknown-tag's report, not this rule's
+            const attributes = tagSchema.attributes ?? {};
+            const parsed = parseMarkdocSpan(token.text);
+            // Defensive only: `token.markdocKind` came from this same parse.
+            if (parsed.kind !== 'tag-open' && parsed.kind !== 'tag-self-closing')
+                continue;
+            // ---- primary: Markdoc's positional value slot, validated against the
+            // schema attribute literally named `primary`. Checked before the
+            // named-attribute loop only because its span offset is always earlier;
+            // the final sort makes that ordering non-load-bearing.
+            let primaryPresent = false;
+            // Hoisted out of the branch below: the duplicate-attribute walk needs
+            // this position too.
+            const primaryToken = token.children.find((child) => child.type === 'markdocTagPrimary');
+            if (parsed.primary) {
+                primaryPresent = true;
+                const { valueKind, value } = parsed.primary;
+                if (!isOpaqueOrSyntaxOwned(valueKind)) {
+                    const position = primaryToken ?? token;
+                    const primarySchema = attributes.primary;
+                    if (!primarySchema) {
+                        // Upstream treats a primary value on a tag that declares no
+                        // `primary` attribute like any other undeclared name, so this is
+                        // the "unknown attribute" class -- `warn`, per AttributeReport.
+                        reports.push({
+                            line: position.startLine,
+                            column: position.startColumn,
+                            context: `"primary" is not a known attribute of "${tagName}" — check for a typo`,
+                            severity: 'warn',
+                        });
+                    }
+                    else if (!primarySchema.dynamic) {
+                        checkValue('primary', valueKind, value, primarySchema, position, reports);
+                    }
+                }
+            }
+            // ---- named attributes. Real Markdoc validates the MERGED
+            // last-write-wins attributes object, not the raw source list, so
+            // `{% t a=1 a=2 %}` with `a` undeclared reports `attribute-undefined`
+            // once, not twice. `lastByName` reproduces that collapse: the
+            // unknown/type/enum checks below fire once per NAME, on the last
+            // occurrence's value and position. The separate duplicate pass further
+            // down still walks every raw occurrence, since it needs the repetition
+            // this map erases.
+            const attributeTokens = token.children.filter((child) => child.type === 'markdocAttribute');
+            // `index` is carried alongside the pair so the value-position lookup in
+            // the loop is an O(1) array read rather than an `indexOf` scan per
+            // entry -- otherwise O(n²) for a long attribute list.
+            const lastByName = new Map();
+            parsed.attributes.forEach((attribute, index) => {
+                const attributeToken = attributeTokens[index];
+                const nameToken = attributeToken?.children.find((child) => child.type === 'markdocAttributeName') ??
+                    attributeToken ??
+                    token;
+                lastByName.set(attribute.name, { attribute, index, position: nameToken });
+            });
+            for (const [attrName, entry] of lastByName) {
+                const { attribute, index: attributeIndex, position: nameTokenPos } = entry;
+                const attrSchema = attributes[attrName];
+                if (!attrSchema) {
+                    // `class`/`id` are never "unknown" when the tag itself declares no
+                    // entry for the name; a tag that does declare its own takes the
+                    // ordinary declared-attribute path (see `GLOBAL_ATTRIBUTE_NAMES`).
+                    if (GLOBAL_ATTRIBUTE_NAMES.has(attrName))
+                        continue;
+                    // `warn` -- the "unknown attribute" class, per AttributeReport.
+                    reports.push({
+                        line: nameTokenPos.startLine,
+                        column: nameTokenPos.startColumn,
+                        context: `"${attrName}" is not a known attribute of "${tagName}" — check for a typo`,
+                        severity: 'warn',
+                    });
+                    continue;
+                }
+                if (attrSchema.dynamic)
+                    continue; // value checks skip dynamic attributes (see schema.ts)
+                if (isOpaqueOrSyntaxOwned(attribute.valueKind))
+                    continue;
+                // Value checks report at the value's own position, not the name's --
+                // the same split `markdoc-syntax` uses for its bareword check.
+                const attributeToken = attributeTokens[attributeIndex];
+                const valueTokenPos = attributeToken?.children.find((child) => child.type === 'markdocAttributeValue') ??
+                    attributeToken ??
+                    token;
+                checkValue(attrName, attribute.valueKind, attribute.value, attrSchema, valueTokenPos, reports);
+            }
+            // ---- missing required. Unlike the type/enum checks above, this runs
+            // even for `dynamic` attributes: upstream enforces `required` purely on
+            // absence, independent of `type`/`matches`/a tag-level `validate()`.
+            // The realm schema has attributes that are both `required` and
+            // `dynamic` (`diagram.file`, `diagram.type`, `code-snippet.file`), so
+            // skipping those would silently diverge from upstream. (`partial.file`
+            // carries no `required` in the composed schema at all.)
+            //
+            // Presence folds three sources: named attributes, the positional
+            // primary (any value kind -- even a `bareword`, whose shape is
+            // `markdoc-syntax`'s report; it still occupies the slot, so `required`
+            // is satisfied and nothing double-reports), and class/id shortcuts.
+            const presentNames = new Set(lastByName.keys());
+            if (primaryPresent)
+                presentNames.add('primary');
+            for (const shortcut of parsed.shortcuts ?? [])
+                presentNames.add(shortcut.kind);
+            for (const [attrName, attrSchema] of Object.entries(attributes)) {
+                if (!attrSchema.required || presentNames.has(attrName))
+                    continue;
+                reports.push({
+                    line: token.startLine,
+                    column: token.startColumn,
+                    context: `"${tagName}" is missing its required "${attrName}" attribute`,
+                });
+            }
+            // ---- duplicate-attribute. One pass over the positional primary, every
+            // named attribute and every shortcut IN SOURCE ORDER, replicating real
+            // Markdoc's own parser, the only place it raises this error:
+            //
+            // - The positional primary, a named attribute and an `id` shortcut all
+            //   go through one branch upstream, which checks whether the name is
+            //   already set, reports if so, then marks it set either way. The
+            //   primary always sits at the lowest offset, so it can only ever be
+            //   the item something else collides WITH, never the collider.
+            // - A `class` shortcut takes a separate branch that never checks -- it
+            //   only merges into the `class` map -- so class shortcuts never
+            //   collide with each other.
+            // - Hence an order-dependent asymmetry: `{% t .a class="b" %}` reports
+            //   a duplicate, while `{% t class="b" .a %}` reports nothing. Walking
+            //   in true source order reproduces both verdicts; direction-agnostic
+            //   set membership would not.
+            const shortcutTokens = token.children.filter((child) => child.type === 'markdocShortcut');
+            const duplicateItems = [
+                ...(parsed.primary
+                    ? [
+                        {
+                            offset: parsed.primary.valueStart,
+                            checked: true,
+                            name: 'primary',
+                            position: primaryToken ?? token,
+                        },
+                    ]
+                    : []),
+                ...parsed.attributes.map((attribute, index) => ({
+                    offset: attribute.nameStart,
+                    checked: true,
+                    name: attribute.name,
+                    position: attributeTokens[index]?.children.find((child) => child.type === 'markdocAttributeName') ??
+                        attributeTokens[index] ??
+                        token,
+                })),
+                ...(parsed.shortcuts ?? []).map((shortcut, index) => ({
+                    offset: shortcut.start,
+                    checked: shortcut.kind === 'id',
+                    name: shortcut.kind, // the schema attribute it folds into, not its own text
+                    position: shortcutTokens[index] ?? token,
+                })),
+            ];
+            duplicateItems.sort((a, b) => a.offset - b.offset);
+            const setNames = new Set();
+            for (const item of duplicateItems) {
+                if (item.checked && setNames.has(item.name)) {
+                    reports.push({
+                        line: item.position.startLine,
+                        column: item.position.startColumn,
+                        context: `"${item.name}" is already set earlier on this tag`,
+                    });
+                }
+                setNames.add(item.name);
+            }
+        }
+        reports.sort((a, b) => a.line - b.line || a.column - b.column);
+        for (const report of reports)
+            ctx.onError(report);
+    },
+};
+//# sourceMappingURL=markdoc-attributes.js.map

package/dist/rules/token/markdoc-attributes.js.map

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

package/dist/rules/token/markdoc-pairing.d.ts

@@ -0,0 +1,3 @@
+import type { TokenRule } from '../types.js';
+export declare const markdocPairing: TokenRule;
+//# sourceMappingURL=markdoc-pairing.d.ts.map

package/dist/rules/token/markdoc-pairing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdoc-pairing.d.ts","sourceRoot":"","sources":["../../../src/rules/token/markdoc-pairing.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAiB7C,eAAO,MAAM,cAAc,EAAE,SAsE5B,CAAC"}

package/dist/rules/token/markdoc-pairing.js

@@ -0,0 +1,73 @@
+/**
+ * The tag's own name, from its synthesized `markdocTagName` child. Only
+ * `tag-open`/`tag-close` tokens ever reach a pairing bucket and both always
+ * carry a name child, so the `''` fallback is defensive only.
+ */
+function tagName(token) {
+    return token.children.find((child) => child.type === 'markdocTagName')?.text ?? '';
+}
+export const markdocPairing = {
+    name: 'markdoc-pairing',
+    tags: ['markdoc'],
+    fixable: false,
+    defaults: {
+        message: '%s',
+    },
+    check(ctx) {
+        if (!ctx.markdoc)
+            return; // flag off -- no markdocTag tokens exist to pair at all
+        const { pairing, selfClosingTags } = ctx.markdoc;
+        // Each bucket below has its own order, so emitting inline would
+        // interleave lines (a line-90 unclosed before a line-12 orphan). Reports
+        // are collected and sorted into document order before they leave the rule.
+        const reports = [];
+        for (const open of pairing.unclosed) {
+            reports.push({
+                token: open,
+                context: `"${tagName(open)}" is opened here but never closed before the document ends`,
+            });
+        }
+        for (const close of pairing.orphaned) {
+            // The open may exist but be malformed (e.g. a multi-line tag inside a
+            // blockquote) rather than genuinely absent, so the message must not
+            // claim the open is missing.
+            reports.push({
+                token: close,
+                context: `"/${tagName(close)}" close tag found, but no well-formed matching open was found`,
+            });
+        }
+        for (const pair of pairing.crossed) {
+            reports.push({
+                token: pair.open,
+                context: `"${tagName(pair.open)}" and its close are interleaved (crossed) with another tag pair instead of properly nested — Markdoc requires tags to nest`,
+            });
+        }
+        for (const open of pairing.voidMissingSlash) {
+            const name = tagName(open);
+            reports.push({ token: open, context: `"${name}" is self-closing — write {% ${name} /%}` });
+        }
+        // Self-closing tag used with an explicit close, detected from `pairs`
+        // since no bucket covers it. Without a schema the set is empty, which
+        // makes this inert just as `voidMissingSlash` already is.
+        if (selfClosingTags.size > 0) {
+            for (const pair of pairing.pairs) {
+                const name = tagName(pair.open);
+                if (!selfClosingTags.has(name))
+                    continue;
+                reports.push({
+                    token: pair.open,
+                    context: `"${name}" is self-closing and must not be used with a matching {% /${name} %} close — write {% ${name} /%} instead`,
+                });
+            }
+        }
+        reports.sort((a, b) => a.token.startLine - b.token.startLine || a.token.startColumn - b.token.startColumn);
+        for (const report of reports) {
+            ctx.onError({
+                line: report.token.startLine,
+                column: report.token.startColumn,
+                context: report.context,
+            });
+        }
+    },
+};
+//# sourceMappingURL=markdoc-pairing.js.map

package/dist/rules/token/markdoc-pairing.js.map

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

package/dist/rules/token/markdoc-syntax.d.ts

@@ -0,0 +1,3 @@
+import type { TokenRule } from '../types.js';
+export declare const markdocSyntax: TokenRule;
+//# sourceMappingURL=markdoc-syntax.d.ts.map

package/dist/rules/token/markdoc-syntax.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdoc-syntax.d.ts","sourceRoot":"","sources":["../../../src/rules/token/markdoc-syntax.ts"],"names":[],"mappings":"AA8BA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,eAAO,MAAM,aAAa,EAAE,SAgG3B,CAAC"}

package/dist/rules/token/markdoc-syntax.js

@@ -0,0 +1,119 @@
+// Grammar-level Markdoc syntax validation -- detection-only. Uses
+// `markdocKind` as a cheap short-circuit, then re-parses each tag's own text
+// via `parseMarkdocSpan` for the semantic detail the `Token` never retains:
+// the parse `reason` and each attribute/primary's `valueKind`. Re-parsing
+// keeps this rule from forcing a `reason`/`attributes` field onto the `Token`
+// shape that it would be the only consumer of.
+//
+// Every check here is GRAMMAR-level, so it fires the same way on a custom tag
+// and under `schema: false` as under the realm schema -- real Markdoc rejects
+// these shapes regardless of any schema. That is why this rule never reads
+// `ctx.markdoc.schema`, only the flag-is-on signal.
+//
+// Reports:
+// - `malformed` spans, with the parser's `reason`, positioned at the offending
+//   character when `reasonOffset` gives one.
+// - close tags carrying attributes: Markdoc's close-tag production is `'/'
+//   TagName` only, but recheck's span parser parses an attribute list anyway,
+//   so this rule is what surfaces it.
+// - bareword values in an attribute OR the positional `primary` slot, both
+//   critical parse errors upstream. `primary` is checked as its own field
+//   because iterating `attributes` alone would miss it.
+//
+// Deliberately never reports: `{%- -%}` trim markers (stripped before parsing
+// sees them), glued attributes (`a=1b=2`, parsed as two attributes),
+// duplicate attributes (`markdoc-attributes` owns the class/id-fold-aware
+// version), or annotation/variable/function kinds (out of scope; skipped
+// explicitly below rather than relying on their attribute lists being empty).
+import { filterByTypes } from '../../parser/index.js';
+import { parseMarkdocSpan } from '../../parser/markdoc/span.js';
+import { offsetToPosition } from '../../parser/markdoc/structure.js';
+export const markdocSyntax = {
+    name: 'markdoc-syntax',
+    tags: ['markdoc'],
+    fixable: false,
+    defaults: {
+        message: 'Markdoc syntax error',
+    },
+    check(ctx) {
+        // Flag off: no `markdocTag` tokens exist in the tree at all, so this is a
+        // defensive no-op rather than something the loop below must handle.
+        if (!ctx.markdoc)
+            return;
+        for (const token of filterByTypes(ctx.tree, ['markdocTag'])) {
+            // Annotation/variable/function bodies are out of scope. Skipping up
+            // front is cheaper and clearer than relying on their attribute lists
+            // coming back empty.
+            if (token.markdocKind === 'annotation' ||
+                token.markdocKind === 'variable' ||
+                token.markdocKind === 'function') {
+                continue;
+            }
+            const parsed = parseMarkdocSpan(token.text);
+            if (parsed.kind === 'malformed') {
+                // `reasonOffset` is relative to the span text, so it is converted to
+                // a document position instead of quoted in the message -- a
+                // span-relative "at position 7" next to the report's own absolute
+                // column reads as a contradiction. When the scanner had no single
+                // offending position (empty body, missing delimiter), the tag's own
+                // start stands in.
+                const position = parsed.reasonOffset === undefined
+                    ? { line: token.startLine, column: token.startColumn }
+                    : offsetToPosition(token, parsed.reasonOffset);
+                ctx.onError({
+                    line: position.line,
+                    column: position.column,
+                    context: token.text,
+                    detail: parsed.reason,
+                });
+                continue; // malformed spans carry no attributes/primary to check further
+            }
+            // Reported at the first attribute's own position when that synthesized
+            // child exists, falling back to the tag's start.
+            if (parsed.kind === 'tag-close' && parsed.attributes.length > 0) {
+                const firstAttribute = token.children.find((child) => child.type === 'markdocAttribute');
+                const position = firstAttribute ?? token;
+                ctx.onError({
+                    line: position.startLine,
+                    column: position.startColumn,
+                    context: token.text,
+                    detail: `close tag "{% /${parsed.name} %}" must not carry attributes — Markdoc's close-tag syntax accepts none`,
+                });
+                // Stop here: the fix just reported is to delete the whole attribute
+                // list, so also advising a reader to quote a bareword inside it would
+                // contradict that.
+                continue;
+            }
+            // Primary is checked before the attribute loop because it sits right
+            // after the tag name, so its offset is always the earlier one. This rule
+            // emits as it goes and never sorts, so check order is emission order.
+            if (parsed.primary?.valueKind === 'bareword' && parsed.name !== null) {
+                const primaryToken = token.children.find((child) => child.type === 'markdocTagPrimary');
+                const position = primaryToken ?? token;
+                ctx.onError({
+                    line: position.startLine,
+                    column: position.startColumn,
+                    context: token.text,
+                    detail: `quote the value: {% ${parsed.name} "${String(parsed.primary.value)}" %}`,
+                });
+            }
+            // structure.ts synthesizes attribute children in the same source order
+            // as `parsed.attributes`, so index-aligning the two arrays is safe and
+            // reuses the offset-to-position math structure.ts already did.
+            const attributeTokens = token.children.filter((child) => child.type === 'markdocAttribute');
+            parsed.attributes.forEach((attribute, index) => {
+                if (attribute.valueKind !== 'bareword')
+                    return;
+                const valueToken = attributeTokens[index]?.children.find((child) => child.type === 'markdocAttributeValue');
+                const position = valueToken ?? token;
+                ctx.onError({
+                    line: position.startLine,
+                    column: position.startColumn,
+                    context: token.text,
+                    detail: `quote the value: ${attribute.name}="${String(attribute.value)}"`,
+                });
+            });
+        }
+    },
+};
+//# sourceMappingURL=markdoc-syntax.js.map

package/dist/rules/token/markdoc-syntax.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdoc-syntax.js","sourceRoot":"","sources":["../../../src/rules/token/markdoc-syntax.ts"],"names":[],"mappings":"AAAA,kEAAkE;AAClE,6EAA6E;AAC7E,4EAA4E;AAC5E,0EAA0E;AAC1E,8EAA8E;AAC9E,+CAA+C;AAC/C,EAAE;AACF,8EAA8E;AAC9E,8EAA8E;AAC9E,2EAA2E;AAC3E,oDAAoD;AACpD,EAAE;AACF,WAAW;AACX,+EAA+E;AAC/E,6CAA6C;AAC7C,2EAA2E;AAC3E,8EAA8E;AAC9E,sCAAsC;AACtC,2EAA2E;AAC3E,0EAA0E;AAC1E,wDAAwD;AACxD,EAAE;AACF,8EAA8E;AAC9E,qEAAqE;AACrE,0EAA0E;AAC1E,yEAAyE;AACzE,8EAA8E;AAC9E,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AAGrE,MAAM,CAAC,MAAM,aAAa,GAAc;IACtC,IAAI,EAAE,gBAAgB;IACtB,IAAI,EAAE,CAAC,SAAS,CAAC;IACjB,OAAO,EAAE,KAAK;IACd,QAAQ,EAAE;QACR,OAAO,EAAE,sBAAsB;KAChC;IACD,KAAK,CAAC,GAAG;QACP,0EAA0E;QAC1E,oEAAoE;QACpE,IAAI,CAAC,GAAG,CAAC,OAAO;YAAE,OAAO;QAEzB,KAAK,MAAM,KAAK,IAAI,aAAa,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,YAAY,CAAC,CAAC,EAAE,CAAC;YAC5D,oEAAoE;YACpE,qEAAqE;YACrE,qBAAqB;YACrB,IACE,KAAK,CAAC,WAAW,KAAK,YAAY;gBAClC,KAAK,CAAC,WAAW,KAAK,UAAU;gBAChC,KAAK,CAAC,WAAW,KAAK,UAAU,EAChC,CAAC;gBACD,SAAS;YACX,CAAC;YAED,MAAM,MAAM,GAAG,gBAAgB,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YAE5C,IAAI,MAAM,CAAC,IAAI,KAAK,WAAW,EAAE,CAAC;gBAChC,qEAAqE;gBACrE,4DAA4D;gBAC5D,kEAAkE;gBAClE,kEAAkE;gBAClE,oEAAoE;gBACpE,mBAAmB;gBACnB,MAAM,QAAQ,GACZ,MAAM,CAAC,YAAY,KAAK,SAAS;oBAC/B,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,CAAC,WAAW,EAAE;oBACtD,CAAC,CAAC,gBAAgB,CAAC,KAAK,EAAE,MAAM,CAAC,YAAY,CAAC,CAAC;gBACnD,GAAG,CAAC,OAAO,CAAC;oBACV,IAAI,EAAE,QAAQ,CAAC,IAAI;oBACnB,MAAM,EAAE,QAAQ,CAAC,MAAM;oBACvB,OAAO,EAAE,KAAK,CAAC,IAAI;oBACnB,MAAM,EAAE,MAAM,CAAC,MAAM;iBACtB,CAAC,CAAC;gBACH,SAAS,CAAC,+DAA+D;YAC3E,CAAC;YAED,uEAAuE;YACvE,iDAAiD;YACjD,IAAI,MAAM,CAAC,IAAI,KAAK,WAAW,IAAI,MAAM,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBAChE,MAAM,cAAc,GAAG,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,KAAK,kBAAkB,CAAC,CAAC;gBACzF,MAAM,QAAQ,GAAG,cAAc,IAAI,KAAK,CAAC;gBACzC,GAAG,CAAC,OAAO,CAAC;oBACV,IAAI,EAAE,QAAQ,CAAC,SAAS;oBACxB,MAAM,EAAE,QAAQ,CAAC,WAAW;oBAC5B,OAAO,EAAE,KAAK,CAAC,IAAI;oBACnB,MAAM,EAAE,kBAAkB,MAAM,CAAC,IAAI,0EAA0E;iBAChH,CAAC,CAAC;gBACH,oEAAoE;gBACpE,sEAAsE;gBACtE,mBAAmB;gBACnB,SAAS;YACX,CAAC;YAED,qEAAqE;YACrE,yEAAyE;YACzE,sEAAsE;YACtE,IAAI,MAAM,CAAC,OAAO,EAAE,SAAS,KAAK,UAAU,IAAI,MAAM,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;gBACrE,MAAM,YAAY,GAAG,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,KAAK,mBAAmB,CAAC,CAAC;gBACxF,MAAM,QAAQ,GAAG,YAAY,IAAI,KAAK,CAAC;gBACvC,GAAG,CAAC,OAAO,CAAC;oBACV,IAAI,EAAE,QAAQ,CAAC,SAAS;oBACxB,MAAM,EAAE,QAAQ,CAAC,WAAW;oBAC5B,OAAO,EAAE,KAAK,CAAC,IAAI;oBACnB,MAAM,EAAE,uBAAuB,MAAM,CAAC,IAAI,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,MAAM;iBAClF,CAAC,CAAC;YACL,CAAC;YAED,uEAAuE;YACvE,uEAAuE;YACvE,+DAA+D;YAC/D,MAAM,eAAe,GAAG,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,KAAK,kBAAkB,CAAC,CAAC;YAC5F,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,SAAS,EAAE,KAAK,EAAE,EAAE;gBAC7C,IAAI,SAAS,CAAC,SAAS,KAAK,UAAU;oBAAE,OAAO;gBAC/C,MAAM,UAAU,GAAG,eAAe,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,IAAI,CACtD,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,KAAK,uBAAuB,CAClD,CAAC;gBACF,MAAM,QAAQ,GAAG,UAAU,IAAI,KAAK,CAAC;gBACrC,GAAG,CAAC,OAAO,CAAC;oBACV,IAAI,EAAE,QAAQ,CAAC,SAAS;oBACxB,MAAM,EAAE,QAAQ,CAAC,WAAW;oBAC5B,OAAO,EAAE,KAAK,CAAC,IAAI;oBACnB,MAAM,EAAE,oBAAoB,SAAS,CAAC,IAAI,KAAK,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG;iBAC1E,CAAC,CAAC;YACL,CAAC,CAAC,CAAC;QACL,CAAC;IACH,CAAC;CACF,CAAC"}

package/dist/rules/token/markdoc-unknown-tag.d.ts

@@ -0,0 +1,3 @@
+import type { TokenRule } from '../types.js';
+export declare const markdocUnknownTag: TokenRule;
+//# sourceMappingURL=markdoc-unknown-tag.d.ts.map

package/dist/rules/token/markdoc-unknown-tag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdoc-unknown-tag.d.ts","sourceRoot":"","sources":["../../../src/rules/token/markdoc-unknown-tag.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAgB7C,eAAO,MAAM,iBAAiB,EAAE,SAsC/B,CAAC"}

package/dist/rules/token/markdoc-unknown-tag.js

@@ -0,0 +1,64 @@
+// Schema-aware "is this even a real tag" check; `markdoc-attributes` validates
+// a known tag's attribute list. Detection-only, and only ever a warning: an
+// unknown tag is often intentional -- a project's own tag, or one the schema
+// generator couldn't statically resolve (see the carve-out below).
+//
+// `ctx.markdoc.schema` is `null` under `schema: false`, which makes this rule
+// inert (parsing and pairing still run). A custom tag declared via
+// `extend.tags` is merged into `schema.tags` by `resolveMarkdocConfig` before
+// it reaches here, so it validates as known with no extra plumbing.
+//
+// Only `tag-open`/`tag-self-closing` kinds are checked: real Markdoc raises
+// exactly one `tag-undefined` per unknown tag node, at the open, so checking
+// the matching close would double-report the same name.
+// `annotation`/`variable`/`function` kinds carry no tag name at all and never
+// reach Markdoc's tag lookup either way, and `malformed` spans have no
+// reliably parseable name and are `markdoc-syntax`'s report already.
+import { filterByTypes } from '../../parser/index.js';
+/**
+ * Realm registers `schemaDefinition` inline in its own markdoc options, not in
+ * the tag module `scripts/generate-markdoc-schema.mjs` reads, so it can never
+ * appear in `MARKDOC_REALM_SCHEMA` even though every Realm build has it.
+ * Without this carve-out the rule would warn on an always-valid tag name.
+ */
+const KNOWN_UNKNOWN_TAGS = new Set(['schemaDefinition']);
+export const markdocUnknownTag = {
+    name: 'markdoc-unknown-tag',
+    tags: ['markdoc'],
+    fixable: false,
+    // Bare placeholder: every `onError` call supplies the complete sentence via
+    // `context`, so tests can assert whole messages with `toBe`.
+    defaults: {
+        message: '%s',
+    },
+    check(ctx) {
+        if (!ctx.markdoc)
+            return; // flag off -- no markdocTag tokens exist at all
+        const { schema } = ctx.markdoc;
+        if (!schema)
+            return; // `schema: false` -- nothing to check tag names against
+        // Collected then sorted rather than reported inline: `tree.flat` happens
+        // to yield `markdocTag` tokens in document order today, but that is not a
+        // guarantee this rule should lean on silently.
+        const reports = [];
+        for (const token of filterByTypes(ctx.tree, ['markdocTag'])) {
+            if (token.markdocKind !== 'tag-open' && token.markdocKind !== 'tag-self-closing')
+                continue;
+            const nameChild = token.children.find((child) => child.type === 'markdocTagName');
+            const name = nameChild?.text;
+            if (!name)
+                continue; // defensive only: both kinds always carry a name child
+            if (schema.tags[name] || KNOWN_UNKNOWN_TAGS.has(name))
+                continue;
+            reports.push({
+                line: token.startLine,
+                column: token.startColumn,
+                context: `"${name}" is not a known Markdoc tag — check for a typo, or declare it via "extend.tags" if intentional`,
+            });
+        }
+        reports.sort((a, b) => a.line - b.line || a.column - b.column);
+        for (const report of reports)
+            ctx.onError(report);
+    },
+};
+//# sourceMappingURL=markdoc-unknown-tag.js.map

package/dist/rules/token/markdoc-unknown-tag.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdoc-unknown-tag.js","sourceRoot":"","sources":["../../../src/rules/token/markdoc-unknown-tag.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,4EAA4E;AAC5E,6EAA6E;AAC7E,mEAAmE;AACnE,EAAE;AACF,8EAA8E;AAC9E,mEAAmE;AACnE,8EAA8E;AAC9E,oEAAoE;AACpE,EAAE;AACF,4EAA4E;AAC5E,6EAA6E;AAC7E,wDAAwD;AACxD,8EAA8E;AAC9E,uEAAuE;AACvE,qEAAqE;AACrE,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAGtD;;;;;GAKG;AACH,MAAM,kBAAkB,GAAwB,IAAI,GAAG,CAAC,CAAC,kBAAkB,CAAC,CAAC,CAAC;AAQ9E,MAAM,CAAC,MAAM,iBAAiB,GAAc;IAC1C,IAAI,EAAE,qBAAqB;IAC3B,IAAI,EAAE,CAAC,SAAS,CAAC;IACjB,OAAO,EAAE,KAAK;IACd,4EAA4E;IAC5E,6DAA6D;IAC7D,QAAQ,EAAE;QACR,OAAO,EAAE,IAAI;KACd;IACD,KAAK,CAAC,GAAG;QACP,IAAI,CAAC,GAAG,CAAC,OAAO;YAAE,OAAO,CAAC,gDAAgD;QAC1E,MAAM,EAAE,MAAM,EAAE,GAAG,GAAG,CAAC,OAAO,CAAC;QAC/B,IAAI,CAAC,MAAM;YAAE,OAAO,CAAC,wDAAwD;QAE7E,yEAAyE;QACzE,0EAA0E;QAC1E,+CAA+C;QAC/C,MAAM,OAAO,GAAuB,EAAE,CAAC;QAEvC,KAAK,MAAM,KAAK,IAAI,aAAa,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,YAAY,CAAC,CAAC,EAAE,CAAC;YAC5D,IAAI,KAAK,CAAC,WAAW,KAAK,UAAU,IAAI,KAAK,CAAC,WAAW,KAAK,kBAAkB;gBAAE,SAAS;YAE3F,MAAM,SAAS,GAAG,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,KAAK,gBAAgB,CAAC,CAAC;YAClF,MAAM,IAAI,GAAG,SAAS,EAAE,IAAI,CAAC;YAC7B,IAAI,CAAC,IAAI;gBAAE,SAAS,CAAC,uDAAuD;YAE5E,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,kBAAkB,CAAC,GAAG,CAAC,IAAI,CAAC;gBAAE,SAAS;YAEhE,OAAO,CAAC,IAAI,CAAC;gBACX,IAAI,EAAE,KAAK,CAAC,SAAS;gBACrB,MAAM,EAAE,KAAK,CAAC,WAAW;gBACzB,OAAO,EAAE,IAAI,IAAI,iGAAiG;aACnH,CAAC,CAAC;QACL,CAAC;QAED,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC;QAC/D,KAAK,MAAM,MAAM,IAAI,OAAO;YAAE,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IACpD,CAAC;CACF,CAAC"}

package/dist/rules/token/messages.d.ts

@@ -0,0 +1,4 @@
+import type { TokenRule, TokenRuleOnErrorInfo } from '../types.js';
+export declare function formatTemplate(template: string, ...values: string[]): string;
+export declare function formatTokenMessage(configMessage: string | undefined, rule: TokenRule, info: TokenRuleOnErrorInfo): string;
+//# sourceMappingURL=messages.d.ts.map

package/dist/rules/token/messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../../src/rules/token/messages.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAEnE,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,CAU5E;AAED,wBAAgB,kBAAkB,CAChC,aAAa,EAAE,MAAM,GAAG,SAAS,EACjC,IAAI,EAAE,SAAS,EACf,IAAI,EAAE,oBAAoB,GACzB,MAAM,CAMR"}

package/dist/rules/token/messages.js

@@ -0,0 +1,20 @@
+export function formatTemplate(template, ...values) {
+    let result = '';
+    let rest = template;
+    for (const value of values) {
+        const index = rest.indexOf('%s');
+        if (index === -1)
+            break;
+        result += rest.slice(0, index) + value;
+        rest = rest.slice(index + 2);
+    }
+    return result + rest;
+}
+export function formatTokenMessage(configMessage, rule, info) {
+    const base = configMessage ?? String(rule.defaults.message ?? rule.name);
+    const substituted = info.context ? formatTemplate(base, info.context) : base;
+    return info.detail && !substituted.includes(info.detail)
+        ? `${substituted} (${info.detail})`
+        : substituted;
+}
+//# sourceMappingURL=messages.js.map

package/dist/rules/token/messages.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.js","sourceRoot":"","sources":["../../../src/rules/token/messages.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,cAAc,CAAC,QAAgB,EAAE,GAAG,MAAgB;IAClE,IAAI,MAAM,GAAG,EAAE,CAAC;IAChB,IAAI,IAAI,GAAG,QAAQ,CAAC;IACpB,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACjC,IAAI,KAAK,KAAK,CAAC,CAAC;YAAE,MAAM;QACxB,MAAM,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,GAAG,KAAK,CAAC;QACvC,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC;IAC/B,CAAC;IACD,OAAO,MAAM,GAAG,IAAI,CAAC;AACvB,CAAC;AAED,MAAM,UAAU,kBAAkB,CAChC,aAAiC,EACjC,IAAe,EACf,IAA0B;IAE1B,MAAM,IAAI,GAAG,aAAa,IAAI,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,IAAI,IAAI,CAAC,IAAI,CAAC,CAAC;IACzE,MAAM,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,cAAc,CAAC,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IAC7E,OAAO,IAAI,CAAC,MAAM,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC;QACtD,CAAC,CAAC,GAAG,WAAW,KAAK,IAAI,CAAC,MAAM,GAAG;QACnC,CAAC,CAAC,WAAW,CAAC;AAClB,CAAC"}

package/dist/rules/token/no-alt-text.d.ts

@@ -0,0 +1,3 @@
+import type { TokenRule } from '../types.js';
+export declare const noAltText: TokenRule;
+//# sourceMappingURL=no-alt-text.d.ts.map

package/dist/rules/token/no-alt-text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-alt-text.d.ts","sourceRoot":"","sources":["../../../src/rules/token/no-alt-text.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAQ7C,eAAO,MAAM,SAAS,EAAE,SA2CvB,CAAC"}