@markuplint/rules 5.0.0-rc.0 → 5.0.0-rc.2

package/lib/permitted-contents/count-pattern.d.ts

@@ -1,4 +1,4 @@
-import type { ChildNode, Options, Result, Specs } from './types.js';
+import type { ChildNode, Mode, Options, Result, Specs, TagRule } from './types.js';
 import type { PermittedContentOneOrMore, PermittedContentOptional, PermittedContentRequire, PermittedContentZeroOrMore } from '@markuplint/ml-spec';
 import type { ReadonlyDeep } from 'type-fest';
 /**
@@ -12,9 +12,12 @@ import type { ReadonlyDeep } from 'type-fest';
  *
  * @param pattern - A quantified content model pattern (require, optional, oneOrMore, or zeroOrMore).
  * @param childNodes - The child nodes to validate against the repeated pattern.
+ * @param rules - User-defined tag rules. Threaded through for transparent-model recursion;
+ *                not consulted here directly. See `order` for the rationale.
  * @param specs - The resolved spec data for content model lookups.
  * @param options - Validation behavior options.
  * @param depth - The current recursion depth, used for debug logging and nested evaluation.
+ * @param mode - Whether we are evaluating the element's `'origin'` or `'pretended'` identity.
  * @returns A result indicating whether the required count of matches was achieved.
  */
-export declare function countPattern(pattern: ReadonlyDeep<PermittedContentOneOrMore> | ReadonlyDeep<PermittedContentOptional> | ReadonlyDeep<PermittedContentRequire> | ReadonlyDeep<PermittedContentZeroOrMore>, childNodes: readonly ChildNode[], specs: Specs, options: Options, depth: number): Result;
+export declare function countPattern(pattern: ReadonlyDeep<PermittedContentOneOrMore> | ReadonlyDeep<PermittedContentOptional> | ReadonlyDeep<PermittedContentRequire> | ReadonlyDeep<PermittedContentZeroOrMore>, childNodes: readonly ChildNode[], rules: readonly TagRule[], specs: Specs, options: Options, depth: number, mode: Mode): Result;

package/lib/permitted-contents/count-pattern.js

@@ -13,14 +13,17 @@ const cLog = cmLog.extend('countCompereResult');
  *
  * @param pattern - A quantified content model pattern (require, optional, oneOrMore, or zeroOrMore).
  * @param childNodes - The child nodes to validate against the repeated pattern.
+ * @param rules - User-defined tag rules. Threaded through for transparent-model recursion;
+ *                not consulted here directly. See `order` for the rationale.
  * @param specs - The resolved spec data for content model lookups.
  * @param options - Validation behavior options.
  * @param depth - The current recursion depth, used for debug logging and nested evaluation.
+ * @param mode - Whether we are evaluating the element's `'origin'` or `'pretended'` identity.
  * @returns A result indicating whether the required count of matches was achieved.
  */
 export function countPattern(pattern, 
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-childNodes, specs, options, depth) {
+childNodes, rules, specs, options, depth, mode) {
     const ptLog = cmLog.extend(`countPattern#${depth}`);
     const collection = new Collection(childNodes);
     const { model, min, max, repeat, missingType } = normalizeModel(pattern);
@@ -31,7 +34,7 @@ childNodes, specs, options, depth) {
     while (true) {
         loopCount++;
         ptLog('Check#%s: %s', loopCount, collection);
-        const result = recursiveBranch(model, collection.unmatched, specs, options, depth);
+        const result = recursiveBranch(model, collection.unmatched, rules, specs, options, depth, mode);
         const added = collection.addMatched(result.matched);
         const { matchedCount } = collection;
         if (result.type === 'UNMATCHED_SELECTOR_BUT_MAY_EMPTY') {
@@ -130,9 +133,14 @@ childNodes, specs, options, depth) {
             continue;
         }
         ptLog('%s:\n  model: %s\n  max: %s\n  collection: %s\n  matched element: %s', resultType, modelLog(model, repeat), max, collection, matchedCount);
-        if (result.type === 'MISSING_NODE_REQUIRED' ||
-            result.type === 'MISSING_NODE_ONE_OR_MORE' ||
-            result.type === 'TRANSPARENT_MODEL_DISALLOWS') {
+        // When min=0 and no elements were consumed, the pattern legitimately
+        // matched zero times — don't propagate the inner sequence's failure.
+        // This enables zeroOrMore([oneOrMore dt, oneOrMore dd]) to accept
+        // empty content (e.g., <dl></dl>). See #3592.
+        if ((collection.matchedCount > 0 || min > 0) &&
+            (result.type === 'MISSING_NODE_REQUIRED' ||
+                result.type === 'MISSING_NODE_ONE_OR_MORE' ||
+                result.type === 'TRANSPARENT_MODEL_DISALLOWS')) {
             return compereResult({
                 type: result.type,
                 matched: collection.matched,

package/lib/permitted-contents/index.d.ts

@@ -9,7 +9,13 @@ import type { Options, TagRule } from './types.js';
  * For each element, it resolves the applicable content model (from the HTML spec or
  * user-defined tag rules), evaluates the element's children against that model, and
  * reports violations such as unexpected elements, missing required elements, or
- * disallowed content through transparent models.
+ * disallowed content through transparent models. It also checks forbidden ancestor
+ * constraints — elements like `<header>`, `<footer>`, `<main>`, and `<address>` must
+ * not appear as descendants of certain other elements as defined by the HTML spec.
+ * Additionally, it enforces required ancestor constraints (`descendantOf`) — certain
+ * elements must appear as descendants of specific other elements. It also validates
+ * sibling-unique attribute constraints (`uniqueAttrs`) — certain attributes must not
+ * appear on more than one element of the same type within the same parent.
  */
 declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<TagRule[], Options>>;
 export default _default;

package/lib/permitted-contents/index.js

@@ -12,7 +12,13 @@ import { transparentMode } from './represent-transparent-nodes.js';
  * For each element, it resolves the applicable content model (from the HTML spec or
  * user-defined tag rules), evaluates the element's children against that model, and
  * reports violations such as unexpected elements, missing required elements, or
- * disallowed content through transparent models.
+ * disallowed content through transparent models. It also checks forbidden ancestor
+ * constraints — elements like `<header>`, `<footer>`, `<main>`, and `<address>` must
+ * not appear as descendants of certain other elements as defined by the HTML spec.
+ * Additionally, it enforces required ancestor constraints (`descendantOf`) — certain
+ * elements must appear as descendants of specific other elements. It also validates
+ * sibling-unique attribute constraints (`uniqueAttrs`) — certain attributes must not
+ * appear on more than one element of the same type within the same parent.
  */
 export default createRule({
     meta: meta,
@@ -23,83 +29,165 @@ export default createRule({
     },
     async verify({ document, report, t }) {
         await document.walkOn('Element', el => {
-            const results = contentModel(el, el.rule.value, el.rule.options);
-            for (const { type, scope, query, hint } of results) {
-                let message = '';
-                if (hint.max != null) {
-                    message =
-                        t('there is more content than it needs') +
-                            t('. ') +
-                            t('the max number of elements required is {0}', `${hint.max}`);
-                }
-                switch (type) {
-                    case 'MATCHED':
-                    case 'MATCHED_ZERO': {
-                        break;
-                    }
-                    case 'MISSING_NODE_ONE_OR_MORE': {
-                        if (scope.rule.options.ignoreHasMutableChildren &&
-                            (!scope.is(scope.ELEMENT_NODE) || scope.hasMutableChildren())) {
-                            break;
-                        }
-                        message =
-                            message ||
-                                t('Require {0}', t('one or more elements')) + t('. ') + '(' + t('Need "{0*}"', query) + ')';
+            // Check forbidden ancestors
+            const elSpec = document.specs.specs.find(s => s.name === el.localName);
+            const forbiddenAncestors = elSpec?.contentModel?.forbiddenAncestors;
+            if (forbiddenAncestors && forbiddenAncestors.length > 0) {
+                let ancestor = el.parentElement;
+                while (ancestor) {
+                    if (forbiddenAncestors.some(selector => ancestor.matches(selector))) {
                         report({
-                            scope,
-                            message,
+                            scope: el,
+                            message: t('{0} must not appear as a descendant of {1}', t('the "{0}" {1}', el.localName, 'element'), t('the "{0}" {1}', ancestor.localName, 'element')),
                         });
                         break;
                     }
-                    case 'MISSING_NODE_REQUIRED': {
-                        if (scope.rule.options.ignoreHasMutableChildren &&
-                            (!scope.is(scope.ELEMENT_NODE) || scope.hasMutableChildren())) {
-                            break;
-                        }
-                        message =
-                            message ||
-                                t('Require {0}', t('an {0}', 'element')) + t('. ') + '(' + t('Need "{0*}"', query) + ')';
-                        report({
-                            scope,
-                            message,
-                        });
+                    ancestor = ancestor.parentElement;
+                }
+            }
+            // Check required ancestor (descendantOf)
+            const descendantOf = elSpec?.contentModel?.descendantOf;
+            if (descendantOf) {
+                let ancestor = el.parentElement;
+                let found = false;
+                while (ancestor) {
+                    if (ancestor.matches(descendantOf)) {
+                        found = true;
                         break;
                     }
-                    case 'UNEXPECTED_EXTRA_NODE': {
-                        const not = hint.not ?? scope;
-                        message =
-                            message ||
-                                (transparentMode.has(scope)
-                                    ? t('{0} is not allowed in {1} through the transparent model in this context', name(not, t), name(el, t))
-                                    : t('{0} is not allowed in {1} in this context', name(not, t), name(el, t)));
-                        report({
-                            scope: not,
-                            message,
-                        });
-                        break;
+                    ancestor = ancestor.parentElement;
+                }
+                if (!found) {
+                    report({
+                        scope: el,
+                        message: t('{0} must appear as a descendant of {1}', t('the "{0}" {1}', el.localName, 'element'), t('the "{0}" {1}', descendantOf, 'element')),
+                    });
+                }
+            }
+            // Check unique attributes among siblings of the same type
+            const uniqueAttrs = elSpec?.contentModel?.uniqueAttrs;
+            if (uniqueAttrs && uniqueAttrs.length > 0) {
+                for (const attrName of uniqueAttrs) {
+                    if (!el.hasAttribute(attrName)) {
+                        continue;
                     }
-                    case 'TRANSPARENT_MODEL_DISALLOWS': {
-                        const not = hint.not ?? scope;
-                        const tp = hint.transparent ?? el;
-                        report({
-                            scope: not,
-                            message: t('{0} is {1} but {2}', name(tp, t), t('a {0}', 'transparent model'), t('also disallows {0} in this context', name(not, t))),
-                        });
-                        break;
+                    const parent = el.parentElement;
+                    if (!parent) {
+                        continue;
                     }
-                    case 'NOTHING': {
+                    // Only report on the second (and subsequent) element that has the attribute
+                    const precedingSiblings = [...parent.children];
+                    const elIndex = precedingSiblings.indexOf(el);
+                    const hasPrecedingDuplicate = precedingSiblings
+                        .slice(0, elIndex)
+                        .some(child => child.localName === el.localName && child.hasAttribute(attrName));
+                    if (hasPrecedingDuplicate) {
                         report({
                             scope: el,
-                            message: t('{0} disallows {1}', t('the {0}', 'element'), 'contents'),
+                            message: t('The "{0}" attribute must not appear on more than one "{1}" element within the same parent', attrName, el.localName),
                         });
-                        break;
                     }
-                    default: {
-                        throw new Error('Unreachable code');
+                }
+            }
+            // Build the mode list. `'pretended'` always runs and preserves the historical
+            // behaviour. `'origin'` additionally fires when the element is pretending and
+            // the user has declared a content model keyed on its original AST name, so
+            // that user-defined custom-tag rules are not silently bypassed by pretending
+            // (see issue #3739).
+            const modes = ['pretended'];
+            if (el.pretenderContext?.type === 'pretender' && el.rule.value.some(r => r.tag === el.rawName)) {
+                modes.push('origin');
+            }
+            for (const mode of modes) {
+                const results = contentModel(el, el.rule.value, el.rule.options, mode);
+                for (const { type, scope, query, hint } of results) {
+                    let message = '';
+                    if (hint.max != null) {
+                        message =
+                            t('there is more content than it needs') +
+                                t('. ') +
+                                t('the max number of elements required is {0}', `${hint.max}`);
+                    }
+                    switch (type) {
+                        case 'MATCHED':
+                        case 'MATCHED_ZERO': {
+                            break;
+                        }
+                        case 'MISSING_NODE_ONE_OR_MORE': {
+                            if (scope.rule.options.ignoreHasMutableChildren &&
+                                (!scope.is(scope.ELEMENT_NODE) || scope.hasMutableChildren())) {
+                                break;
+                            }
+                            message =
+                                message ||
+                                    t('Require {0}', t('one or more elements')) +
+                                        t('. ') +
+                                        '(' +
+                                        t('Need "{0*}"', query) +
+                                        ')';
+                            report({
+                                scope,
+                                message,
+                            });
+                            break;
+                        }
+                        case 'MISSING_NODE_REQUIRED': {
+                            if (scope.rule.options.ignoreHasMutableChildren &&
+                                (!scope.is(scope.ELEMENT_NODE) || scope.hasMutableChildren())) {
+                                break;
+                            }
+                            message =
+                                message ||
+                                    t('Require {0}', t('an {0}', 'element')) +
+                                        t('. ') +
+                                        '(' +
+                                        t('Need "{0*}"', query) +
+                                        ')';
+                            report({
+                                scope,
+                                message,
+                            });
+                            break;
+                        }
+                        case 'UNEXPECTED_EXTRA_NODE': {
+                            const not = hint.not ?? scope;
+                            message =
+                                message ||
+                                    (transparentMode.has(scope)
+                                        ? t('{0} is not allowed in {1} through the transparent model in this context', name(not, t, mode), name(el, t, mode))
+                                        : t('{0} is not allowed in {1} in this context', name(not, t, mode), name(el, t, mode)));
+                            report({
+                                scope: not,
+                                message,
+                            });
+                            break;
+                        }
+                        case 'TRANSPARENT_MODEL_DISALLOWS': {
+                            const not = hint.not ?? scope;
+                            const tp = hint.transparent ?? el;
+                            report({
+                                scope: not,
+                                message: t('{0} is {1} but {2}', name(tp, t, mode), t('a {0}', 'transparent model'), t('also disallows {0} in this context', name(not, t, mode))),
+                            });
+                            break;
+                        }
+                        case 'NOTHING': {
+                            report({
+                                scope: el,
+                                message: t('{0} disallows {1}', t('the {0}', 'element'), 'contents'),
+                            });
+                            break;
+                        }
+                        default: {
+                            throw new Error('Unreachable code');
+                        }
                     }
                 }
+                // Clear the per-element transparent-model tracker between passes so that
+                // errors reported in one mode do not carry the "through the transparent
+                // model" phrasing into the other mode's diagnostics.
+                transparentMode.clear();
             }
-            transparentMode.clear();
         });
     },
 });
@@ -108,15 +196,22 @@ export default createRule({
  * Used in error messages to describe the offending node (e.g., 'the "div" element',
  * 'the text node', 'the comment', 'the doctype', 'the code block').
  *
+ * In `'origin'` mode, uses {@link MLElement.rawName} so that the diagnostic refers
+ * to the original AST identity (e.g. the component name `"Breadcrumbs"`) rather
+ * than the pretender target (`"nav"`). `'pretended'` mode preserves the historical
+ * behaviour and prints the visible `localName`.
+ *
  * @param scope - The child node to generate a name for.
  * @param t - The translator function for localized message formatting.
+ * @param mode - Which identity to surface in the message.
  * @returns A localized string describing the node.
  */
 function name(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-scope, t) {
+scope, t, mode) {
     if (scope.is(scope.ELEMENT_NODE)) {
-        return t('the "{0}" {1}', scope.localName, 'element');
+        const displayName = mode === 'origin' ? scope.rawName : scope.localName;
+        return t('the "{0}" {1}', displayName, 'element');
     }
     if (scope.is(scope.TEXT_NODE)) {
         return t('the {0}', 'text node');

package/lib/permitted-contents/matches-selector.d.ts

@@ -1,4 +1,4 @@
-import type { ChildNode, Result, Specs } from './types.js';
+import type { ChildNode, Mode, Result, Specs } from './types.js';
 /**
  * Extended result type for selector matching that includes additional
  * intermediate states: a selector that did not match but allows empty content,
@@ -19,4 +19,4 @@ export type SelectorResult = Result<'UNMATCHED_SELECTOR_BUT_MAY_EMPTY' | 'MISSIN
  * @param depth - The current recursion depth, used for debug logging namespacing.
  * @returns A selector result indicating match status with diagnostic hints.
  */
-export declare function matchesSelector(query: string, childNode: ChildNode | undefined, specs: Specs, depth: number): SelectorResult;
+export declare function matchesSelector(query: string, childNode: ChildNode | undefined, specs: Specs, depth: number, mode: Mode): SelectorResult;

package/lib/permitted-contents/matches-selector.js

@@ -17,9 +17,9 @@ import { cleanObject, matches } from './utils.js';
  */
 export function matchesSelector(query, 
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-childNode, specs, depth) {
+childNode, specs, depth, mode) {
     const nodeLog = cmLog.extend(`node#${depth}`);
-    const { selector, hasText, hasCustom } = optCondition(query, specs);
+    const { selector, hasText, hasNonEmptyText, hasCustom } = optCondition(query, specs);
     if (childNode == null) {
         if (hasText) {
             nodeLog('<#text>.matches(%s) => ""', query);
@@ -32,6 +32,7 @@ childNode, specs, depth) {
                 hint: {},
             };
         }
+        // #nonEmptyText requires actual non-empty text — missing node is not acceptable
         return {
             type: 'MISSING_NODE',
             matched: [],
@@ -42,6 +43,28 @@ childNode, specs, depth) {
         };
     }
     if (childNode.is(childNode.TEXT_NODE)) {
+        if (hasNonEmptyText) {
+            if (childNode.isWhitespace()) {
+                nodeLog('<#nonEmptyText>.matches(%s) => WHITESPACE (rejected)', query);
+                return {
+                    type: 'MISSING_NODE',
+                    matched: [],
+                    unmatched: [],
+                    zeroMatch: false,
+                    query,
+                    hint: {},
+                };
+            }
+            nodeLog('<#nonEmptyText>.matches(%s) => "%s"', query, childNode.raw.trim());
+            return {
+                type: 'MATCHED',
+                matched: [childNode],
+                unmatched: [],
+                zeroMatch: false,
+                query,
+                hint: {},
+            };
+        }
         if (hasText) {
             nodeLog('<#text>.matches(%s) => "%s"', query, childNode.raw.trim());
             return {
@@ -80,7 +103,7 @@ childNode, specs, depth) {
             type: 'MATCHED',
             matched: [childNode],
             unmatched: [],
-            zeroMatch: !!hasText,
+            zeroMatch: !!(hasText || hasNonEmptyText),
             query,
             hint: {},
         };
@@ -97,7 +120,7 @@ childNode, specs, depth) {
                 hint: {},
             };
         }
-        const result = matches(selector, childNode, specs);
+        const result = matches(selector, childNode, specs, mode);
         nodeLog('%s.matches(%s) => %s', childNode.raw, query, result.matched);
         if (result.matched) {
             return {
@@ -149,11 +172,19 @@ const conditionWithoutSpecs = {
         selector: '#custom',
         hasCustom: true,
         hasText: false,
+        hasNonEmptyText: false,
     },
     '#text': {
         selector: '#text',
         hasCustom: false,
         hasText: true,
+        hasNonEmptyText: false,
+    },
+    '#nonEmptyText': {
+        selector: '#nonEmptyText',
+        hasCustom: false,
+        hasText: false,
+        hasNonEmptyText: true,
     },
 };
 /**
@@ -185,8 +216,14 @@ function optCondition(query, specs) {
     }
     let hasCustom = false;
     let hasText = false;
+    let hasNonEmptyText = false;
     const selector = query.replace(/^:model\(([^)]+)\)|^#([a-z-]+)/, (_, $model, _model) => {
-        const _selectors = contentModelCategoryToTagNames(`#${$model ?? _model}`, specs.def);
+        const tag = `#${$model ?? _model}`;
+        if (tag === '#nonEmptyText') {
+            hasNonEmptyText = true;
+            return '';
+        }
+        const _selectors = contentModelCategoryToTagNames(tag, specs.def);
         if (_selectors.length === 0) {
             throw new Error(`${$model ?? _model} is empty`);
         }
@@ -208,6 +245,7 @@ function optCondition(query, specs) {
         selector,
         hasCustom,
         hasText,
+        hasNonEmptyText,
     };
     queryCaches.set(query, result);
     optConditionSpecsBaseCaches.set(specs, queryCaches);

package/lib/permitted-contents/order.d.ts

@@ -1,4 +1,4 @@
-import type { ChildNode, Options, Result, Specs } from './types.js';
+import type { ChildNode, Mode, Options, Result, Specs, TagRule } from './types.js';
 import type { PermittedContentPattern } from '@markuplint/ml-spec';
 import type { ReadonlyDeep } from 'type-fest';
 /**
@@ -13,9 +13,16 @@ import type { ReadonlyDeep } from 'type-fest';
  *
  * @param contents - An ordered array of content model patterns to match sequentially.
  * @param childNodes - The child nodes to validate against the patterns.
+ * @param rules - User-defined tag rules. `order` does not consult them directly; they are
+ *                threaded through so nested helpers (especially `representTransparentNodes`)
+ *                can resolve content models via `resolveContentModel`. Do not remove even if
+ *                it looks unused here.
  * @param specs - The resolved spec data for content model lookups.
  * @param options - Validation behavior options.
  * @param depth - The current recursion depth, used for debug logging and nested pattern matching.
+ * @param mode - Whether we are evaluating the element's `'origin'` or `'pretended'` identity.
+ *               Propagated unchanged into `complexBranch` so downstream selector matching
+ *               honors the same view.
  * @returns A result indicating overall match status and the matched/unmatched node partitioning.
  */
-export declare function order(contents: ReadonlyDeep<PermittedContentPattern[]>, childNodes: readonly ChildNode[], specs: Specs, options: Options, depth: number): Result;
+export declare function order(contents: ReadonlyDeep<PermittedContentPattern[]>, childNodes: readonly ChildNode[], rules: readonly TagRule[], specs: Specs, options: Options, depth: number, mode: Mode): Result;

package/lib/permitted-contents/order.js

@@ -14,14 +14,21 @@ import { Collection, mergeHints, modelLog } from './utils.js';
  *
  * @param contents - An ordered array of content model patterns to match sequentially.
  * @param childNodes - The child nodes to validate against the patterns.
+ * @param rules - User-defined tag rules. `order` does not consult them directly; they are
+ *                threaded through so nested helpers (especially `representTransparentNodes`)
+ *                can resolve content models via `resolveContentModel`. Do not remove even if
+ *                it looks unused here.
  * @param specs - The resolved spec data for content model lookups.
  * @param options - Validation behavior options.
  * @param depth - The current recursion depth, used for debug logging and nested pattern matching.
+ * @param mode - Whether we are evaluating the element's `'origin'` or `'pretended'` identity.
+ *               Propagated unchanged into `complexBranch` so downstream selector matching
+ *               honors the same view.
  * @returns A result indicating overall match status and the matched/unmatched node partitioning.
  */
 export function order(contents, 
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-childNodes, specs, options, depth) {
+childNodes, rules, specs, options, depth, mode) {
     const orderLog = cmLog.extend(`order#${depth}`);
     const btLog = cmLog.extend(`backtrack#${depth}`);
     const patterns = deepCopy(contents);
@@ -33,7 +40,7 @@ childNodes, specs, options, depth) {
     let afterBacktrack = false;
     const unmatchedResults = [];
     while (patterns.length > 0 && patterns[0]) {
-        result = complexBranch(patterns[0], collection.unmatched, specs, options, depth);
+        result = complexBranch(patterns[0], collection.unmatched, rules, specs, options, depth, mode);
         collection.addMatched(result.matched);
         if (result.type !== 'UNEXPECTED_EXTRA_NODE' && result.type !== 'MATCHED' && result.type !== 'MATCHED_ZERO') {
             unmatchedResults.push(result);

package/lib/permitted-contents/recursive-branch.d.ts

@@ -1,5 +1,5 @@
 import type { SelectorResult } from './matches-selector.js';
-import type { ChildNode, Options, Specs } from './types.js';
+import type { ChildNode, Mode, Options, Specs, TagRule } from './types.js';
 import type { PermittedContentPattern, Model } from '@markuplint/ml-spec';
 import type { ReadonlyDeep } from 'type-fest';
 /**
@@ -14,9 +14,12 @@ import type { ReadonlyDeep } from 'type-fest';
  *
  * @param model - Either a terminal model (selector string or array of selector strings) or a nested pattern array.
  * @param childNodes - The child nodes to validate against the model.
+ * @param rules - User-defined tag rules. Threaded through for transparent-model recursion;
+ *                not consulted here directly. See `order` for the rationale.
  * @param specs - The resolved spec data for content model lookups.
  * @param options - Validation behavior options.
  * @param depth - The current recursion depth, used for debug logging and nested evaluation.
+ * @param mode - Whether we are evaluating the element's `'origin'` or `'pretended'` identity.
  * @returns A selector result indicating whether the first unmatched child node matches the model.
  */
-export declare function recursiveBranch(model: ReadonlyDeep<Model | PermittedContentPattern[]>, childNodes: readonly ChildNode[], specs: Specs, options: Options, depth: number): SelectorResult;
+export declare function recursiveBranch(model: ReadonlyDeep<Model | PermittedContentPattern[]>, childNodes: readonly ChildNode[], rules: readonly TagRule[], specs: Specs, options: Options, depth: number, mode: Mode): SelectorResult;

package/lib/permitted-contents/recursive-branch.js

@@ -13,24 +13,27 @@ import { Collection, isModel } from './utils.js';
  *
  * @param model - Either a terminal model (selector string or array of selector strings) or a nested pattern array.
  * @param childNodes - The child nodes to validate against the model.
+ * @param rules - User-defined tag rules. Threaded through for transparent-model recursion;
+ *                not consulted here directly. See `order` for the rationale.
  * @param specs - The resolved spec data for content model lookups.
  * @param options - Validation behavior options.
  * @param depth - The current recursion depth, used for debug logging and nested evaluation.
+ * @param mode - Whether we are evaluating the element's `'origin'` or `'pretended'` identity.
  * @returns A selector result indicating whether the first unmatched child node matches the model.
  */
 export function recursiveBranch(model, 
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-childNodes, specs, options, depth) {
+childNodes, rules, specs, options, depth, mode) {
     if (!isModel(model)) {
-        return order(model, childNodes, specs, options, depth + 1);
+        return order(model, childNodes, rules, specs, options, depth + 1, mode);
     }
     if (typeof model === 'string') {
-        return matchesSelector(model, childNodes[0], specs, depth);
+        return matchesSelector(model, childNodes[0], specs, depth, mode);
     }
     const collection = new Collection(childNodes);
     let lastUnmatched = null;
     for (const query of model) {
-        const result = matchesSelector(query, collection.unmatched[0], specs, depth);
+        const result = matchesSelector(query, collection.unmatched[0], specs, depth, mode);
         collection.addMatched(result.matched);
         if (result.type === 'MATCHED' || result.type === 'MATCHED_ZERO') {
             return {

package/lib/permitted-contents/represent-transparent-nodes.d.ts

@@ -1,4 +1,4 @@
-import type { ChildNode, Options, Result, Specs } from './types.js';
+import type { ChildNode, Mode, Options, Result, Specs, TagRule } from './types.js';
 /**
  * A map tracking child nodes that are currently being evaluated through
  * a transparent content model. Used to prevent infinite recursion and
@@ -58,5 +58,5 @@ type TransparentNode = {
  * @returns An array of possible transparent node resolutions, each with flattened nodes and accumulated errors.
  * @see https://github.com/markuplint/markuplint/issues/3249
  */
-export declare function representTransparentNodes(childNodes: readonly ChildNode[], specs: Specs, options: Options): TransparentNode[];
+export declare function representTransparentNodes(childNodes: readonly ChildNode[], rules: readonly TagRule[], specs: Specs, options: Options, mode: Mode): TransparentNode[];
 export {};

package/lib/permitted-contents/represent-transparent-nodes.js

@@ -1,4 +1,4 @@
-import { getContentModel } from '@markuplint/ml-spec';
+import { resolveContentModel } from './content-model.js';
 import { order } from './order.js';
 import { Collection, isTransparent, matches } from './utils.js';
 /**
@@ -82,10 +82,10 @@ const MAX_PATTERNS = 1024;
  */
 export function representTransparentNodes(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-childNodes, specs, options) {
+childNodes, rules, specs, options, mode) {
     const parentElement = childNodes[0]?.parentElement;
     const parentResults = parentElement
-        ? representTransparentNodes([parentElement], specs, options)
+        ? representTransparentNodes([parentElement], rules, specs, options, mode)
         : [{ nodes: [], errors: [] }];
     let patterns = [[]];
     for (const childNode of childNodes) {
@@ -95,7 +95,7 @@ childNodes, specs, options) {
             }
             continue;
         }
-        const models = getContentModel(childNode, specs.specs);
+        const models = resolveContentModel(childNode, rules, specs, mode);
         if (models == null || typeof models === 'boolean') {
             for (const p of patterns) {
                 p.push(childNode);
@@ -117,7 +117,7 @@ childNodes, specs, options) {
             const collection = new Collection([...branchChildNodes]);
             let unmatched;
             if (noTransparentModels.length > 0) {
-                const result = order(noTransparentModels, collection.unmatched, specs, options, Number.POSITIVE_INFINITY);
+                const result = order(noTransparentModels, collection.unmatched, rules, specs, options, Number.POSITIVE_INFINITY, mode);
                 unmatched = result.unmatched;
             }
             else {
@@ -135,7 +135,7 @@ childNodes, specs, options) {
                 }
                 transparentMode.set(child, true);
                 if (child.is(child.ELEMENT_NODE)) {
-                    const transparentCondMatched = matches(transparent.transparent, child, specs);
+                    const transparentCondMatched = matches(transparent.transparent, child, specs, mode);
                     if (!transparentCondMatched.matched) {
                         branchChildren.push({
                             type: 'TRANSPARENT_MODEL_DISALLOWS',