@wix/origami-lint 1.34.26 → 1.34.28

package/dist/rules/site-app/css-file-nesting.js

@@ -37,7 +37,7 @@ function checkTopLevel(root, file, report) {
 }
 function checkTopAtRule(node, file, isLeadingImport, reportInFile) {
     if (node.name === 'import' && isLeadingImport)
-        return reportInFile(node, 'css_import', `\`@import ${node.params.trim()}\` can't be in ${file}: an item's CSS carries no imports (the preview loads the theme from _generated/). Remove the line (tracker CONV-fromBundle.ts:987).`);
+        return reportInFile(node, 'css_import', `\`@import ${node.params.trim()}\` can't be in ${file}: an item's CSS carries no imports (the preview loads the theme from _generated/). Remove the line.`);
     if (node.name === 'custom-media')
         return;
     if (node.name === 'mixin' && file !== 'layout.css')
@@ -48,19 +48,19 @@ function checkTopAtRule(node, file, isLeadingImport, reportInFile) {
         return;
     if (BREAKPOINT_AT_RULES.includes(node.name))
         return checkBreakpoint(node, file, reportInFile);
-    reportInFile(node, 'unsupported_top_level_at_rule', `\`@${node.name}\` isn't part of the export format at the top of ${file}. At the top level only @media, @scope, @custom-media${file === 'layout.css' ? '' : ' and @mixin'} are allowed${pageMixinNote(file)} (tracker CONV-utils.ts:92).`);
+    reportInFile(node, 'unsupported_top_level_at_rule', `\`@${node.name}\` isn't part of the export format at the top of ${file}. At the top level only @media, @scope, @custom-media${file === 'layout.css' ? '' : ' and @mixin'} are allowed${pageMixinNote(file)}.`);
 }
 /** Reports a bare declaration at the top of layout.css (CONV-astParser.ts:412); style.css and theme.css drop one silently. */
 function checkTopLevelDeclaration(node, file, reportInFile) {
     if (file !== 'layout.css')
         return;
-    reportInFile(node, 'top_level_declaration', `\`${node.prop}: ${node.value}\` is at the top level. Put the declaration inside the element's rule (\`.comp-a { … }\`) (tracker CONV-astParser.ts:412).`);
+    reportInFile(node, 'top_level_declaration', `\`${node.prop}: ${node.value}\` is at the top level. Put the declaration inside the element's rule (\`.comp-a { … }\`).`);
 }
 /** A layout `@scope` holds exactly one `@media`, checked before its block (CONV-astParser.ts:399, as parseCssAst does). */
 function checkLayoutScope(node, reportInFile) {
     const scopeChildren = node.nodes === undefined ? [] : getCssChildren(node);
     if (scopeChildren.length !== 1 || !isMedia(scopeChildren[0])) {
-        return reportInFile(node, 'invalid_scope_content', `\`@scope ${node.params.trim()}\` must hold exactly one \`@media (…) { … }\` block. Put the rules inside one @media in the @scope (tracker CONV-astParser.ts:399).`);
+        return reportInFile(node, 'invalid_scope_content', `\`@scope ${node.params.trim()}\` must hold exactly one \`@media (…) { … }\` block. Put the rules inside one @media in the @scope.`);
     }
     if (hasBlock(scopeChildren[0], reportInFile))
         checkBreakpointContent(scopeChildren[0], 'layout.css', reportInFile);
@@ -83,7 +83,7 @@ function getScopedMedia(node, reportInFile) {
             continue;
         }
         if (!isMedia(first)) {
-            reportInFile(current, 'invalid_scope_content', `\`@scope ${current.params.trim()}\` must start with a \`@media (…) { … }\` block: put the rules inside it (tracker CONV-utils.ts:92).`);
+            reportInFile(current, 'invalid_scope_content', `\`@scope ${current.params.trim()}\` must start with a \`@media (…) { … }\` block: put the rules inside it.`);
             return null;
         }
         if (!hasBlock(first, reportInFile))
@@ -98,16 +98,16 @@ function checkBreakpointContent(media, file, reportInFile) {
         if (child.type === 'rule')
             checkRule(child, file, reportInFile);
         else if (child.type === 'atrule')
-            reportInFile(child, 'at_rule_in_breakpoint', `\`@${child.name}\` inside \`${describeAtRule(media)}\` is not allowed. A breakpoint block holds only element rules: declare \`@mixin\` at the top level${pageMixinNote(file)} and put its breakpoint variant in a \`@media\` inside its \`@result\`; don't nest one \`@media\` in another (tracker CONV-astParser.ts:147).`);
+            reportInFile(child, 'at_rule_in_breakpoint', `\`@${child.name}\` inside \`${describeAtRule(media)}\` is not allowed. A breakpoint block holds only element rules: declare \`@mixin\` at the top level${pageMixinNote(file)} and put its breakpoint variant in a \`@media\` inside its \`@result\`; don't nest one \`@media\` in another.`);
         else if (child.type === 'decl')
-            reportInFile(child, 'declaration_in_breakpoint', `\`${child.prop}: ${child.value}\` sits directly in \`${describeAtRule(media)}\`. Wrap it in the element's rule: \`@media (…) { .comp-a { … } }\` (tracker CONV-astParser.ts:151).`);
+            reportInFile(child, 'declaration_in_breakpoint', `\`${child.prop}: ${child.value}\` sits directly in \`${describeAtRule(media)}\`. Wrap it in the element's rule: \`@media (…) { .comp-a { … } }\`.`);
     }
 }
 /** Reports an at-rule written without a block (CONV-utils.ts:76): the import reads every top-level at-rule but `@custom-media` and `@mixin` as a breakpoint. */
 function hasBlock(node, reportInFile) {
     if (node.nodes !== undefined)
         return true;
-    reportInFile(node, 'missing_at_rule_block', `\`${describeAtRule(node)}\` has no block. Give it a \`{ … }\` block with the element rules, or remove it (tracker CONV-utils.ts:76).`);
+    reportInFile(node, 'missing_at_rule_block', `\`${describeAtRule(node)}\` has no block. Give it a \`{ … }\` block with the element rules, or remove it.`);
     return false;
 }
 /** An element rule: layout's (CONV-astParser.ts:74, :51, :54, :57) or style's and theme's (CONV-astParser.ts:95). */
@@ -129,19 +129,19 @@ function checkLayoutRule(rule, reportInFile) {
         }
         const what = child.type === 'rule' ? `the rule \`${child.selector.trim()}\`` : `\`${describeAtRule(child)}\``;
         const fix = child.type === 'rule' ? 'Write it as its own rule' : child.name === 'media' ? `Move it out: \`@media (…) { ${selector} { … } }\` at the top level` : 'Move it out of the rule';
-        reportInFile(child, 'invalid_layout_rule_content', `rule \`${selector}\`: ${what} can't be inside a layout rule, which holds only declarations and @origami-target blocks. ${fix} (tracker CONV-astParser.ts:74).`);
+        reportInFile(child, 'invalid_layout_rule_content', `rule \`${selector}\`: ${what} can't be inside a layout rule, which holds only declarations and @origami-target blocks. ${fix}.`);
     }
 }
 /** An `@origami-target`: a block (CONV-astParser.ts:51), a known name (:54), once per rule (:57), only declarations (:51), in the converter's order. */
 function checkOrigamiTarget(node, selector, seenTargets, reportInFile) {
     const target = node.params.trim();
-    const reportTargetShape = (fix) => reportInFile(node, 'invalid_target_content', `rule \`${selector}\`: \`@origami-target ${target}\` holds only declarations, in a \`{ … }\` block. ${fix} (tracker CONV-astParser.ts:51).`);
+    const reportTargetShape = (fix) => reportInFile(node, 'invalid_target_content', `rule \`${selector}\`: \`@origami-target ${target}\` holds only declarations, in a \`{ … }\` block. ${fix}.`);
     if (node.nodes === undefined)
         return reportTargetShape("Give it a block with the container's declarations");
     if (!ORIGAMI_TARGETS.includes(target))
-        return reportInFile(node, 'unknown_target', `rule \`${selector}\`: \`@origami-target ${target}\` is not a known target. Use \`@origami-target ${ORIGAMI_TARGETS[0]}\` or \`@origami-target ${ORIGAMI_TARGETS[1]}\` (tracker CONV-astParser.ts:54).`);
+        return reportInFile(node, 'unknown_target', `rule \`${selector}\`: \`@origami-target ${target}\` is not a known target. Use \`@origami-target ${ORIGAMI_TARGETS[0]}\` or \`@origami-target ${ORIGAMI_TARGETS[1]}\`.`);
     if (seenTargets.has(target))
-        return reportInFile(node, 'duplicate_target', `rule \`${selector}\`: \`@origami-target ${target}\` appears twice. Merge the two blocks into one (tracker CONV-astParser.ts:57).`);
+        return reportInFile(node, 'duplicate_target', `rule \`${selector}\`: \`@origami-target ${target}\` appears twice. Merge the two blocks into one.`);
     seenTargets.add(target);
     const nested = getCssChildren(node).find((child) => child.type !== 'decl');
     if (!nested)
@@ -153,7 +153,7 @@ function checkStyleRule(rule, reportInFile) {
     const selector = rule.selector.trim();
     for (const child of getCssChildren(rule)) {
         if (child.type === 'atrule' && child.name !== 'apply') {
-            reportInFile(child, 'at_rule_in_style_rule', `rule \`${selector}\`: \`@${child.name}\` can't be nested in a style rule. Put the rule inside it instead: \`@media (…) { ${selector} { … } }\` (in a @mixin: \`@result { @media (…) { &… { … } } }\`) (tracker CONV-astParser.ts:95).`);
+            reportInFile(child, 'at_rule_in_style_rule', `rule \`${selector}\`: \`@${child.name}\` can't be nested in a style rule. Put the rule inside it instead: \`@media (…) { ${selector} { … } }\` (in a @mixin: \`@result { @media (…) { &… { … } } }\`).`);
         }
     }
 }

package/dist/rules/site-app/css-layout-properties.js

@@ -86,7 +86,6 @@ const SPX_RESOLVER_TYPES = ['scale', 'fixed'];
 /** A property allowed at the top of a rule with `@origami-target` blocks (isRootLayoutProperty): the element's own, item and spx properties, and the root-target container property. */
 const isRootProperty = (prop) => prop in ELEMENT_PROPS || prop in ITEM_PROPS || SPX_PROPS.includes(prop) || CONTAINER_PROPS[prop]?.target === 'root';
 const isLayoutProperty = (prop) => isRootProperty(prop) || prop in CONTAINER_PROPS;
-const ROW = (line) => `(tracker CONV-layoutParser.ts:${line})`;
 export default defineRule({
     name: 'css-layout-properties',
     checks: CHECKS,
@@ -129,14 +128,14 @@ function checkPropertiesOnce(declarations, where, reportAt) {
     const seen = new Set();
     for (const decl of declarations) {
         if (seen.has(decl.prop))
-            reportAt(decl, 'duplicate_property', `\`${decl.prop}\` is declared twice in ${where}: keep one ${ROW(498)}.`);
+            reportAt(decl, 'duplicate_property', `\`${decl.prop}\` is declared twice in ${where}: keep one.`);
         seen.add(decl.prop);
     }
 }
 function checkLayoutPropertiesOnly({ element, declarations }, reportAt) {
     for (const decl of declarations) {
         if (!isLayoutProperty(decl.prop))
-            reportAt(decl, 'non_layout_property', `${describeNonLayoutProperty(decl.prop, element)} ${ROW(505)}.`);
+            reportAt(decl, 'non_layout_property', `${describeNonLayoutProperty(decl.prop, element)}.`);
     }
 }
 /** A property the layout tables don't have: in capitals, the import doesn't know it (it reads names as written), else it is paint for style.css. */
@@ -152,9 +151,9 @@ function checkRootPropertiesAtTop({ element, declarations }, reportAt) {
             continue;
         const container = CONTAINER_PROPS[decl.prop];
         if (container)
-            reportAt(decl, 'property_outside_target', `${element}'s \`${decl.prop}\` goes inside \`@origami-target ${container.target} { … }\`, not at the top of its rule ${ROW(512)}.`);
+            reportAt(decl, 'property_outside_target', `${element}'s \`${decl.prop}\` goes inside \`@origami-target ${container.target} { … }\`, not at the top of its rule.`);
         else
-            reportAt(decl, 'non_layout_property', `${describeNonLayoutProperty(decl.prop, element)} ${ROW(512)}.`);
+            reportAt(decl, 'non_layout_property', `${describeNonLayoutProperty(decl.prop, element)}.`);
     }
 }
 /** Each declaration of a target block is a container property of that target; the content block also takes `position: relative` (targetContract.ts). */
@@ -167,11 +166,11 @@ function checkTargetProperties(element, target, declarations, reportAt) {
             continue;
         if (container) {
             const place = container.target === 'root' ? `at the top of ${element}'s rule` : `in \`@origami-target ${container.target}\``;
-            reportAt(decl, 'property_in_wrong_target', `${element}'s \`${decl.prop}\` goes ${place}, not in ${target} ${ROW(524)}.`);
+            reportAt(decl, 'property_in_wrong_target', `${element}'s \`${decl.prop}\` goes ${place}, not in ${target}.`);
         }
         else {
             const fix = isLayoutProperty(decl.prop) ? `move it to the top of ${element}'s rule` : `move it to ${element}'s rule in style.css`;
-            reportAt(decl, 'non_container_target_property', `\`${decl.prop}\` in ${element}'s \`@origami-target ${target}\` block is not a container property: ${fix} ${ROW(524)}.`);
+            reportAt(decl, 'non_container_target_property', `\`${decl.prop}\` in ${element}'s \`@origami-target ${target}\` block is not a container property: ${fix}.`);
         }
     }
 }
@@ -184,7 +183,7 @@ function checkScope(scope, inherited, reportAt) {
     for (const [prop, decl] of values) {
         const value = decl.value.trim();
         if (value === '') {
-            reportAt(decl, 'missing_property_value', `${element}'s \`${prop}\` has no value: write a value or remove the declaration ${ROW(430)}.`);
+            reportAt(decl, 'missing_property_value', `${element}'s \`${prop}\` has no value: write a value or remove the declaration.`);
             continue;
         }
         if (SPX_PROPS.includes(prop))
@@ -192,21 +191,21 @@ function checkScope(scope, inherited, reportAt) {
         const container = CONTAINER_PROPS[prop];
         if (container && type && !container[type]) {
             const [own, other] = type === 'grid' ? ['grid', 'flex'] : ['flex', 'grid'];
-            reportAt(decl, 'incompatible_container_property', `${element} is a ${own} container (\`display: ${own}\`), and \`${prop}\` is a ${other} property: remove it, or use \`display: ${other}\` ${ROW(447)}.`);
+            reportAt(decl, 'incompatible_container_property', `${element} is a ${own} container (\`display: ${own}\`), and \`${prop}\` is a ${other} property: remove it, or use \`display: ${other}\`.`);
             continue;
         }
         if (prop === 'flex-wrap' && ownType === 'stack')
             continue; // :218 reported it; an inherited flex reads it as a value (:437)
         const spec = ELEMENT_PROPS[prop] ?? ITEM_PROPS[prop] ?? container?.spec;
         if (spec && !isReadable(spec, value))
-            reportAt(decl, 'invalid_layout_value', `${element}'s \`${prop}: ${value}\` is not a layout value. Allowed: ${spec.allowed} ${ROW(437)}.`);
+            reportAt(decl, 'invalid_layout_value', `${element}'s \`${prop}: ${value}\` is not a layout value. Allowed: ${spec.allowed}.`);
     }
     if (scope.rulesWithTargets.length && !type) {
-        reportAt(scope.rulesWithTargets[0], 'missing_container_display', `${element} has \`@origami-target\` blocks but no display: add \`display: grid\` or \`display: flex\` in its \`@origami-target ${CONTENT_TARGET}\` block ${ROW(451)}.`);
+        reportAt(scope.rulesWithTargets[0], 'missing_container_display', `${element} has \`@origami-target\` blocks but no display: add \`display: grid\` or \`display: flex\` in its \`@origami-target ${CONTENT_TARGET}\` block.`);
     }
     const gridRow = values.get('grid-row');
     if (gridRow && !values.has('grid-column')) {
-        reportAt(gridRow, 'missing_grid_column', `${element} has \`grid-row\` but no \`grid-column\`: add \`grid-column: <start> / <end>\` (in the same @media, if the grid-row is in one) ${ROW(264)}.`);
+        reportAt(gridRow, 'missing_grid_column', `${element} has \`grid-row\` but no \`grid-column\`: add \`grid-column: <start> / <end>\` (in the same @media, if the grid-row is in one).`);
     }
     return type;
 }
@@ -222,7 +221,7 @@ function checkSpxReference({ element, values }, reportAt) {
         return; // :430 reports the empty one
     if ((refWidthValue === undefined || Number.isFinite(Number(refWidthValue))) && (resolverTypeValue === undefined || SPX_RESOLVER_TYPES.includes(resolverTypeValue)))
         return;
-    reportAt(first, 'invalid_spx_context', `${element}'s spx context is invalid: \`--spx-ref-width\` takes a plain number (1280, no px) and \`--spx-resolver-type\` takes scale or fixed ${ROW(417)}.`);
+    reportAt(first, 'invalid_spx_context', `${element}'s spx context is invalid: \`--spx-ref-width\` takes a plain number (1280, no px) and \`--spx-resolver-type\` takes scale or fixed.`);
 }
 /** The container type the scope's own display gives (resolveContainerType): grid, or flex with no flex-wrap other than nowrap (:218). */
 function checkContainerType({ element, values }, reportAt) {
@@ -234,7 +233,7 @@ function checkContainerType({ element, values }, reportAt) {
     const wrap = values.get('flex-wrap');
     const wrapValue = wrap?.value.trim();
     if (wrap && wrapValue !== '' && wrapValue !== 'nowrap') {
-        reportAt(wrap, 'unsupported_flex_wrap', `${element} has \`flex-wrap: ${wrapValue}\`, which isn't supported: remove it (or write \`nowrap\`), or use \`display: grid\` for items that wrap ${ROW(218)}.`);
+        reportAt(wrap, 'unsupported_flex_wrap', `${element} has \`flex-wrap: ${wrapValue}\`, which isn't supported: remove it (or write \`nowrap\`), or use \`display: grid\` for items that wrap.`);
     }
     return 'stack';
 }
@@ -270,7 +269,7 @@ function checkContainerParent(child, parent, { report }) {
         const parentName = nameOf(parent);
         const props = [...new Set(declarations.map(({ prop }) => prop))].join(', ');
         const line = Math.min(...declarations.map(({ decl }) => decl.line));
-        report({ check: 'child_without_container_layout', loc: child.loc, message: `layout.css:${line}: ${childName} sets item properties (${props}), but its parent ${parentName} has no container layout${media ? ` at @media ${media}` : ''}: give ${parentName} \`display: grid\` or \`display: flex\`, or remove ${childName}'s item properties ${ROW(359)}.` });
+        report({ check: 'child_without_container_layout', loc: child.loc, message: `layout.css:${line}: ${childName} sets item properties (${props}), but its parent ${parentName} has no container layout${media ? ` at @media ${media}` : ''}: give ${parentName} \`display: grid\` or \`display: flex\`, or remove ${childName}'s item properties.` });
     }
 }
 /** The parent's container type at this breakpoint, as the import derives it: its last `display` there (on itself or in its content-wrapper block) when it is grid or flex, else the default's. */

package/dist/rules/site-app/css-selectors.js

@@ -52,7 +52,7 @@ function checkScopeOwner(node, file) {
     const owner = SCOPE_OWNER.exec(params)?.[1];
     if (owner !== undefined && isSafeCssIdentifier(owner))
         return;
-    file.reportAt(node, 'invalid_scope_owner', `\`@scope ${params}\` must name its owner as \`(.<class>)\`, one element's class. Write \`@scope (.${ownClassOf(owner ?? params.replace(/^[(.#\s]+/, ''))})\` (tracker CONV-utils.ts:70).`);
+    file.reportAt(node, 'invalid_scope_owner', `\`@scope ${params}\` must name its owner as \`(.<class>)\`, one element's class. Write \`@scope (.${ownClassOf(owner ?? params.replace(/^[(.#\s]+/, ''))})\`.`);
 }
 /** One rule's selector, in the import's order: the flat global style, the split, the parts, the first part, then the chain. */
 function checkSelector(rule, file) {
@@ -66,13 +66,13 @@ function checkSelector(rule, file) {
         return;
     const [first, ...rest] = parts;
     if (first === undefined)
-        return file.reportAt(rule, 'empty_selector', 'the rule has an empty selector. Start it with the element\'s class: `.comp-a { … }` (tracker CONV-cssSelectors.ts:370).');
+        return file.reportAt(rule, 'empty_selector', 'the rule has an empty selector. Start it with the element\'s class: `.comp-a { … }`.');
     if (first.isAmpersand)
         return checkGlobalStyleChain(first, rest, selector, rule, file);
     if (file.inMixin)
         return;
     if (first.className === undefined)
-        return file.reportAt(rule, 'missing_element_selector', `selector \`${selector}\` doesn't start with an element. Start it with the element's class: \`.comp-a${first.text}\` (tracker CONV-cssSelectors.ts:370).`);
+        return file.reportAt(rule, 'missing_element_selector', `selector \`${selector}\` doesn't start with an element. Start it with the element's class: \`.comp-a${first.text}\`.`);
     const element = splitStateClasses(first);
     if (!checkElementClass(element.className, first.className, selector, rule, file))
         return;
@@ -84,7 +84,7 @@ function checkSelector(rule, file) {
 function checkFlatGlobalStyle(selector, rule, file) {
     if (file.name === 'layout.css' || file.inMixin || !selector.startsWith('--'))
         return true;
-    file.reportAt(rule, 'global_style_as_rule', `\`${selector} { … }\` is not a valid rule. Declare the global style as \`@mixin ${selector} { @result { … } }\` (tracker CONV-astParser.ts:88).`);
+    file.reportAt(rule, 'global_style_as_rule', `\`${selector} { … }\` is not a valid rule. Declare the global style as \`@mixin ${selector} { @result { … } }\`.`);
     return false;
 }
 /** Reports an element class that isn't a plain identifier or is a reserved name (CONV-cssSelectors.ts:54), naming the class as written. */
@@ -92,7 +92,7 @@ function checkElementClass(className, written, selector, rule, file) {
     if (isSafeCssIdentifier(className))
         return true;
     const problem = isCssIdentifier(className) ? `\`${className}\` is a reserved name, not an element class. Give the element another className` : `\`${written}\` is not an element class. ${howToWrite(written, ownClassOf(className))}`;
-    file.reportAt(rule, 'invalid_selector_segment', `in \`${selector}\`, ${problem} (tracker CONV-cssSelectors.ts:54).`);
+    file.reportAt(rule, 'invalid_selector_segment', `in \`${selector}\`, ${problem}.`);
     return false;
 }
 /** A layout.css rule: one element's class (CONV-layoutParser.ts:105), no state (:108); a part with no class is refused first (CONV-cssSelectors.ts:213). */
@@ -102,10 +102,10 @@ function checkLayoutChain(first, rest, selector, rule, file) {
     const state = [first, ...rest].flatMap((part) => part.states)[0];
     if (rest.length) {
         const element = rest.findLast((part) => file.elementClassNames.has(baseClassOf(part))) ?? first;
-        return file.reportAt(rule, 'multiple_layout_elements', `\`${selector}\` names more than one element; a layout rule takes one element's class: write \`.${baseClassOf(element)} { … }\` (layout can't be set on an inner part or through an ancestor) (tracker CONV-layoutParser.ts:105).`);
+        return file.reportAt(rule, 'multiple_layout_elements', `\`${selector}\` names more than one element; a layout rule takes one element's class: write \`.${baseClassOf(element)} { … }\` (layout can't be set on an inner part or through an ancestor).`);
     }
     if (state !== undefined)
-        return file.reportAt(rule, 'layout_by_state', `\`${selector}\` sets layout by state, which isn't supported: remove \`${state}\` from the selector (state changes go in style.css) (tracker CONV-layoutParser.ts:108).`);
+        return file.reportAt(rule, 'layout_by_state', `\`${selector}\` sets layout by state, which isn't supported: remove \`${state}\` from the selector (state changes go in style.css).`);
     checkElementExists(first, rule, file);
 }
 /** A style or theme rule on an element (cssSelectors.ts parseComponentChain): a second element needs a state on the first (:321), carries
@@ -118,9 +118,9 @@ function checkElementChain(first, rest, selector, rule, file) {
         const second = splitStateClasses(rest[0]);
         const third = rest.slice(1).find((part) => isAnotherElement(part, file));
         if (third)
-            return file.reportAt(rule, 'too_many_ancestor_elements', `\`${selector}\` chains three elements. Keep one ancestor: \`.${first.className}${first.states.join('')} .${baseClassOf(third)}\` (tracker CONV-cssSelectors.ts:318).`);
+            return file.reportAt(rule, 'too_many_ancestor_elements', `\`${selector}\` chains three elements. Keep one ancestor: \`.${first.className}${first.states.join('')} .${baseClassOf(third)}\`.`);
         if (!first.states.length)
-            return file.reportAt(rule, 'ancestor_without_state', `\`${selector}\` puts one element under another without a state. Address the element by its own class (\`.${ownClassOf(second.className)}\`), or condition it on the ancestor's state (\`.${first.className}:hover .${ownClassOf(second.className)}\`) (tracker CONV-cssSelectors.ts:321).`);
+            return file.reportAt(rule, 'ancestor_without_state', `\`${selector}\` puts one element under another without a state. Address the element by its own class (\`.${ownClassOf(second.className)}\`), or condition it on the ancestor's state (\`.${first.className}:hover .${ownClassOf(second.className)}\`).`);
         if (second.states.length)
             return reportTwoOwners(first, second, selector, rule, file);
         if (!checkElementClass(second.className, rest[0].className, selector, rule, file))
@@ -149,14 +149,14 @@ function checkInnerPartsHaveNoId(inner, selector, rule, file) {
     const part = inner.find(hasId);
     if (part === undefined)
         return true;
-    file.reportAt(rule, 'inner_part_has_id', `in \`${selector}\`, \`.${part.className}\` is not an inner part: an inner part's selector has no \`#\` id. Use an inner part's selector from the element's contract, without the id (\`.${ownClassOf(part.className)}\`) (tracker CONV-cssSelectors.ts:222).`);
+    file.reportAt(rule, 'inner_part_has_id', `in \`${selector}\`, \`.${part.className}\` is not an inner part: an inner part's selector has no \`#\` id. Use an inner part's selector from the element's contract, without the id (\`.${ownClassOf(part.className)}\`).`);
     return false;
 }
 /** A `@mixin`'s rule, `&…` (cssSelectors.ts parseGlobalStyleChain): outside a `@mixin` it's refused (:377); a later `&` or `:root` is the
  * global-styles rows'; then the inner parts, read as an element's (parseIeChain), with no id (:222). */
 function checkGlobalStyleChain(first, rest, selector, rule, file) {
     if (!file.inMixin)
-        return file.reportAt(rule, 'parent_selector_outside_mixin', `\`${selector}\` is outside a \`@mixin\`. Replace \`&\` with the element's class (\`.comp-a${selector.slice(1)}\`), or move the rule into the global style's \`@mixin\` (tracker CONV-cssSelectors.ts:377).`);
+        return file.reportAt(rule, 'parent_selector_outside_mixin', `\`${selector}\` is outside a \`@mixin\`. Replace \`&\` with the element's class (\`.comp-a${selector.slice(1)}\`), or move the rule into the global style's \`@mixin\`.`);
     if (rest.some((part) => part.isAmpersand || part.text === ':root'))
         return;
     if (!checkInnerParts(rest, first, selector, rule, file))
@@ -171,7 +171,7 @@ function checkInnerParts(inner, owner, selector, rule, file) {
         return false;
     const stated = inner.filter((part) => part.states.length);
     if (stated.length > 1) {
-        file.reportAt(rule, 'multiple_state_owners', `in \`${selector}\`, states sit on \`${stated[0].text}\` and \`${stated[1].text}\`. Attach the states to the one part that owns them (tracker CONV-cssSelectors.ts:213).`);
+        file.reportAt(rule, 'multiple_state_owners', `in \`${selector}\`, states sit on \`${stated[0].text}\` and \`${stated[1].text}\`. Attach the states to the one part that owns them.`);
         return false;
     }
     if (stated.length && owner.states.length) {
@@ -185,19 +185,19 @@ function checkPartsHaveClass(parts, selector, rule, file) {
     const bare = parts.find((part) => part.className === undefined);
     if (!bare)
         return true;
-    file.reportAt(rule, 'state_without_class', `in \`${selector}\`, \`${bare.text}\` has no class. Attach the state to the part that owns it (\`.comp-a:hover\`, \`.comp-a .label:hover\`) and write every later part as a class (tracker CONV-cssSelectors.ts:213).`);
+    file.reportAt(rule, 'state_without_class', `in \`${selector}\`, \`${bare.text}\` has no class. Attach the state to the part that owns it (\`.comp-a:hover\`, \`.comp-a .label:hover\`) and write every later part as a class.`);
     return false;
 }
 /** Reports states on two owners (CONV-cssSelectors.ts:216). */
 function reportTwoOwners(owner, other, selector, rule, file) {
     const name = (part) => (part.isAmpersand ? '&' : `.${baseClassOf(part)}`);
-    file.reportAt(rule, 'multiple_state_owners', `\`${selector}\` puts states on two owners (\`${name(owner)}\` and \`${name(other)}\`). Condition the rule on one owner's states only (tracker CONV-cssSelectors.ts:216).`);
+    file.reportAt(rule, 'multiple_state_owners', `\`${selector}\` puts states on two owners (\`${name(owner)}\` and \`${name(other)}\`). Condition the rule on one owner's states only.`);
 }
 /** Reports a rule for an element that structure.jsx doesn't have (CONV-fromBundle.ts:855). */
 function checkElementExists(element, rule, file) {
     if (file.inMixin || file.elementClassNames.has(element.className))
         return;
-    file.reportAt(rule, 'missing_selector_element', `\`.${element.className}\` styles no element: no element in structure.jsx has className="${element.className}". Remove the rule, or write the className of an element (tracker CONV-fromBundle.ts:855).`);
+    file.reportAt(rule, 'missing_selector_element', `\`.${element.className}\` styles no element: no element in structure.jsx has className="${element.className}". Remove the rule, or write the className of an element.`);
 }
 // ── reading a selector ──
 /** The selector's parts, split as the import splits them (getSelectorSegments, cssSelectors.ts splitSegments), each read as the import
@@ -229,14 +229,14 @@ function reportUnsplittable(selector, rule, file) {
         else if ((char === ']' || char === ')') && !openers.pop())
             return reportUnbalanced(`has a \`${char}\` with no \`${char === ']' ? '[' : '('}\` before it`, selector, rule, file);
         else if (char === ',' && !openers.length) {
-            file.reportAt(rule, 'selector_list', `\`${selector}\` is a selector list. Split it into one rule per selector (tracker CONV-cssSelectors.ts:92).`);
+            file.reportAt(rule, 'selector_list', `\`${selector}\` is a selector list. Split it into one rule per selector.`);
             return null;
         }
     }
     return reportUnbalanced(inQuotes ? 'has an unclosed `"`' : `has an unclosed \`${openers.at(-1)}\``, selector, rule, file);
 }
 function reportUnbalanced(what, selector, rule, file) {
-    file.reportAt(rule, 'unclosed_selector_token', `selector \`${selector}\` ${what}. Close the bracket or quote (tracker CONV-cssSelectors.ts:87).`);
+    file.reportAt(rule, 'unclosed_selector_token', `selector \`${selector}\` ${what}. Close the bracket or quote.`);
     return null;
 }
 /** One part as the import reads it: `:root`, or `&` or a class, then states (`:hover`, `.state-class`); an attribute or functional
@@ -246,7 +246,7 @@ function readPart(text, selector, rule, file) {
         return { text, isAmpersand: false, states: [] };
     const { base, states, unread } = readSegment(text);
     if (unread) {
-        file.reportAt(rule, 'unsupported_selector_syntax', `in \`${selector}\`, the format can't read \`${unread}\`. ${howToWrite(unread, 'comp-a')} (tracker CONV-cssSelectors.ts:169).`);
+        file.reportAt(rule, 'unsupported_selector_syntax', `in \`${selector}\`, the format can't read \`${unread}\`. ${howToWrite(unread, 'comp-a')}.`);
         return null;
     }
     return { text, isAmpersand: base === '&', className: base === '&' ? undefined : base?.slice(1), states };

package/dist/rules/site-app/global-styles.js

@@ -38,7 +38,7 @@ function checkMixin(mixin, reportInFile) {
     }
     const result = getResult(mixin);
     if (!result) {
-        reportInFile(mixin, 'invalid_mixin_result', `\`@mixin --${id}\` must be \`@mixin --${id} { @result { … } }\`. Put everything inside one \`@result { }\` (tracker CONV-astParser.ts:293).`);
+        reportInFile(mixin, 'invalid_mixin_result', `\`@mixin --${id}\` must be \`@mixin --${id} { @result { … } }\`. Put everything inside one \`@result { }\`.`);
         return [];
     }
     const rules = [];
@@ -59,12 +59,12 @@ function checkMixinRule(node, id, breakpoint, rules, reportInFile) {
     const selector = node.selector.trim();
     const inner = getCssChildren(node);
     if (!selector.startsWith('&'))
-        return reportInFile(node, 'missing_parent_selector', `\`@mixin --${id}\`: selector \`${selector}\` must start with \`&\`. Write \`& ${selector}\` (or \`&:hover\`) (tracker CONV-astParser.ts:195).`);
+        return reportInFile(node, 'missing_parent_selector', `\`@mixin --${id}\`: selector \`${selector}\` must start with \`&\`. Write \`& ${selector}\` (or \`&:hover\`).`);
     if (selector === '&')
         return reportInFile(node, 'bare_parent_selector', getBareAmpersandMessage(id, inner));
     const nested = inner.find((child) => child.type === 'rule');
     if (nested)
-        return reportInFile(nested, 'nested_style_rule', `\`@mixin --${id}\`: a rule is nested in \`${selector}\`. Write the whole selector on one rule: \`${joinSelectors(selector, nested.selector.trim())} { … }\` (tracker CONV-astParser.ts:204).`);
+        return reportInFile(nested, 'nested_style_rule', `\`@mixin --${id}\`: a rule is nested in \`${selector}\`. Write the whole selector on one rule: \`${joinSelectors(selector, nested.selector.trim())} { … }\`.`);
     const atRules = inner.filter((child) => child.type === 'atrule');
     const applies = atRules.filter((child) => child.name === 'apply');
     // another at-rule (CONV-astParser.ts:211) is css-file-nesting's; two `@apply`s, one beside declarations, or one that isn't
@@ -76,12 +76,12 @@ function checkMixinRule(node, id, breakpoint, rules, reportInFile) {
 /** An at-rule in `@result`: no `@apply` (:246), no `@mixin` (:251); only `@media` / `@scope` at its top, none inside them (:254). */
 function checkResultAtRule(node, id, breakpoint, rules, reportInFile) {
     if (node.name === 'apply')
-        return reportInFile(node, 'apply_at_result_root', `\`@mixin --${id}\`: \`@apply\` can't sit at the root of \`@result\`. Remove it, or move it into an inner part's rule: \`& .label { @apply ${node.params.trim()}; }\` (tracker CONV-astParser.ts:246).`);
+        return reportInFile(node, 'apply_at_result_root', `\`@mixin --${id}\`: \`@apply\` can't sit at the root of \`@result\`. Remove it, or move it into an inner part's rule: \`& .label { @apply ${node.params.trim()}; }\`.`);
     if (node.name === 'mixin')
-        return reportInFile(node, 'nested_mixin', `\`@mixin --${id}\`: \`@mixin ${node.params.trim()}\` is declared inside it. Declare each \`@mixin\` at the top level of the file (tracker CONV-astParser.ts:251).`);
+        return reportInFile(node, 'nested_mixin', `\`@mixin --${id}\`: \`@mixin ${node.params.trim()}\` is declared inside it. Declare each \`@mixin\` at the top level of the file.`);
     if (breakpoint || !BREAKPOINT_AT_RULES.includes(node.name)) {
         const where = breakpoint ? `\`${describeAtRule(breakpoint)}\` in \`@result\`` : '`@result`';
-        return reportInFile(node, 'invalid_result_at_rule', `\`@mixin --${id}\`: \`@${node.name}\` is not allowed in ${where}. Use only \`@media\` / \`@scope\` directly inside \`@result\`, one level deep (tracker CONV-astParser.ts:254).`);
+        return reportInFile(node, 'invalid_result_at_rule', `\`@mixin --${id}\`: \`@${node.name}\` is not allowed in ${where}. Use only \`@media\` / \`@scope\` directly inside \`@result\`, one level deep.`);
     }
     const media = getBreakpointBody(node);
     if (media)
@@ -103,7 +103,7 @@ function checkSelector(rule, reportInFile) {
     if (repeated === undefined)
         return true;
     const problem = repeated === ':root' ? 'has `:root` after `&`' : 'repeats `&`';
-    reportInFile(rule.node, 'invalid_parent_selector', `\`@mixin --${rule.mixin}\`: selector \`${rule.selector}\` ${problem}. Write \`&\` once, at the start of the selector (tracker CONV-cssSelectors.ts:351).`);
+    reportInFile(rule.node, 'invalid_parent_selector', `\`@mixin --${rule.mixin}\`: selector \`${rule.selector}\` ${problem}. Write \`&\` once, at the start of the selector.`);
     return false;
 }
 /** Each link, in the import's order (collectGlobalStyleLinks): no state (:655), no breakpoint (:664), a dashed id (:670) the file declares (:673), once per part (:677). Returns the parts a link names, by mixin. */
@@ -116,26 +116,26 @@ function checkLinks(links, declaredIds, reportInFile) {
         const linkDescription = `\`@mixin --${link.mixin}\`'s link \`@apply ${child}\``;
         const fix = `write it as \`${getSelectorWithoutStates(link.selector)} { @apply ${child} }\``;
         if (hasState(link.selector)) {
-            reportInFile(link.apply, 'conditional_global_style_link', `${linkDescription} can't be under a state or a breakpoint: ${fix} and put the state / breakpoint values in @mixin ${child} (tracker CONV-styleParser.ts:655).`);
+            reportInFile(link.apply, 'conditional_global_style_link', `${linkDescription} can't be under a state or a breakpoint: ${fix} and put the state / breakpoint values in @mixin ${child}.`);
             continue;
         }
         if (link.breakpoint) {
-            reportInFile(link.apply, 'conditional_global_style_link', `${linkDescription} can't be under a state or a breakpoint: ${fix} outside \`${describeAtRule(link.breakpoint)}\`, and put the breakpoint values in @mixin ${child} (tracker CONV-styleParser.ts:655).`);
+            reportInFile(link.apply, 'conditional_global_style_link', `${linkDescription} can't be under a state or a breakpoint: ${fix} outside \`${describeAtRule(link.breakpoint)}\`, and put the breakpoint values in @mixin ${child}.`);
             continue;
         }
         const part = getPartKey(link);
         linkedParts.add(part);
         const id = getDashedId(child);
         if (!isSafeCssIdentifier(id)) {
-            reportInFile(link.apply, 'invalid_linked_style_id', `\`@mixin --${link.mixin}\` links \`${child}\`, which is not a valid global style name: use letters, digits, - and _ (tracker CONV-styleParser.ts:670).`);
+            reportInFile(link.apply, 'invalid_linked_style_id', `\`@mixin --${link.mixin}\` links \`${child}\`, which is not a valid global style name: use letters, digits, - and _.`);
             continue;
         }
         if (!declaredIds.has(id)) {
-            reportInFile(link.apply, 'missing_linked_style', `\`@mixin --${link.mixin}\` links \`${child}\`, but the file has no \`@mixin ${child}\`: add it (tracker CONV-styleParser.ts:673).`);
+            reportInFile(link.apply, 'missing_linked_style', `\`@mixin --${link.mixin}\` links \`${child}\`, but the file has no \`@mixin ${child}\`: add it.`);
             continue;
         }
         if (validLinkParts.has(part)) {
-            reportInFile(link.apply, 'duplicate_global_style_link', `\`@mixin --${link.mixin}\` links two global styles at \`${getPart(link.selector)}\`: keep one (tracker CONV-styleParser.ts:677).`);
+            reportInFile(link.apply, 'duplicate_global_style_link', `\`@mixin --${link.mixin}\` links two global styles at \`${getPart(link.selector)}\`: keep one.`);
             continue;
         }
         validLinkParts.add(part);
@@ -175,7 +175,7 @@ function checkLinkCycles(validLinks, reportInFile) {
     }
 }
 function reportCycle(link, child, chain, reportInFile) {
-    reportInFile(link.apply, 'mixin_link_cycle', `\`@mixin --${link.mixin}\` links \`--${child}\`, which leads back to it: ${chain.map((id) => `--${id}`).join(' → ')}. A global style can't contain itself: remove this link, or link a style that doesn't lead back to \`--${child}\` (tracker OUR-007).`);
+    reportInFile(link.apply, 'mixin_link_cycle', `\`@mixin --${link.mixin}\` links \`--${child}\`, which leads back to it: ${chain.map((id) => `--${id}`).join(' → ')}. A global style can't contain itself: remove this link, or link a style that doesn't lead back to \`--${child}\`.`);
 }
 /** One selector of a mixin (across its breakpoints): a link alone, or values; values on an inner part where a link names it (CONV-styleParser.ts:803, :698). */
 function checkLinkOrValues(group, linkedParts, reportInFile) {
@@ -183,12 +183,12 @@ function checkLinkOrValues(group, linkedParts, reportInFile) {
     const values = group.filter((rule) => !rule.apply);
     const [first] = group;
     if (link && values.length > 0) {
-        return reportInFile(values[0].node, 'link_with_values', `\`${first.selector}\` of \`@mixin --${first.mixin}\` has both \`@apply ${link.apply.params.trim()}\` and values: move the values into @mixin ${link.apply.params.trim()} (tracker CONV-styleParser.ts:803).`);
+        return reportInFile(values[0].node, 'link_with_values', `\`${first.selector}\` of \`@mixin --${first.mixin}\` has both \`@apply ${link.apply.params.trim()}\` and values: move the values into @mixin ${link.apply.params.trim()}.`);
     }
     const part = getPart(first.selector);
     if (link || part === '' || linkedParts.has(getPartKey(first)))
         return;
-    reportInFile(first.node, 'missing_global_style_link', `\`@mixin --${first.mixin}\` styles \`${part}\` but links no global style there: add \`& ${part} { @apply --<child> }\` and move the values to that child's @mixin (tracker CONV-styleParser.ts:698).`);
+    reportInFile(first.node, 'missing_global_style_link', `\`@mixin --${first.mixin}\` styles \`${part}\` but links no global style there: add \`& ${part} { @apply --<child> }\` and move the values to that child's @mixin.`);
 }
 // ── reading a mixin ──
 /** The `@mixin` a rule of its `@result` sits in. */
@@ -244,15 +244,15 @@ const joinSelectors = (outer, inner) => (inner.includes('&') ? inner.replaceAll(
 function getMixinIdMessage(params) {
     const written = getDashedId(params);
     if (written !== undefined && isCssIdentifier(written) && !isSafeCssIdentifier(written))
-        return `\`@mixin ${params}\`: \`${written}\` is reserved. Name the global style with another dashed identifier (\`@mixin --${written.replace(/^_+|_+$/g, '')}-style\`) (tracker CONV-astParser.ts:287).`;
+        return `\`@mixin ${params}\`: \`${written}\` is reserved. Name the global style with another dashed identifier (\`@mixin --${written.replace(/^_+|_+$/g, '')}-style\`).`;
     const id = /^-*([_a-zA-Z][_a-zA-Z0-9-]*)/.exec(params)?.[1] ?? 'id';
     const state = /[:[]/.test(params) ? `. Write the state as an \`&${params.slice(params.search(/[:[]/))} { … }\` rule inside \`@result\`` : '';
-    return `\`@mixin ${params}\` must name one dashed identifier (\`@mixin --${id}\`)${state} (tracker CONV-astParser.ts:287).`;
+    return `\`@mixin ${params}\` must name one dashed identifier (\`@mixin --${id}\`)${state}.`;
 }
 /** A bare `& { … }` (CONV-astParser.ts:198): its values go straight in `@result`; an `@apply` in it is the import's :658 case, refused here first. */
 function getBareAmpersandMessage(id, inner) {
     const apply = inner.find((child) => child.type === 'atrule' && child.name === 'apply');
     if (apply)
-        return `\`@mixin --${id}\` applies ${apply.params.trim()} to itself, which isn't supported: write the values in @mixin --${id}'s @result, or link a child on an inner part (\`& .label { @apply … }\`) (tracker CONV-astParser.ts:198, CONV-styleParser.ts:658).`;
-    return `\`@mixin --${id}\`: drop the \`& { }\` wrapper and write its declarations directly in \`@result\` (tracker CONV-astParser.ts:198).`;
+        return `\`@mixin --${id}\` applies ${apply.params.trim()} to itself, which isn't supported: write the values in @mixin --${id}'s @result, or link a child on an inner part (\`& .label { @apply … }\`).`;
+    return `\`@mixin --${id}\`: drop the \`& { }\` wrapper and write its declarations directly in \`@result\`.`;
 }

package/dist/rules/site-app/no-free-code.js

@@ -1,9 +1,9 @@
 import { STRUCTURE } from "../../rules-api/index.js";
 import { defineRule } from "./define-rule.js";
 const CHECKS = ['invalid_structure_declaration', 'free_code_outside_structure', 'typescript_syntax'];
-const FREE_CODE = 'The import refuses this statement: a structure file holds only imports, `const` / `let` / `var` declarations and `export const Structure = () => …` (tracker CONV-parseJsx.ts:287).';
-const STRUCTURE_SHAPE = 'Declare Structure once, as `export const Structure = () => ( <Page …/> )`: an exported const arrow that returns the root element directly, with no `{ return … }`, fragment or condition around it (tracker CONV-parseJsx.ts:335).';
-const typeScript = (code) => `\`${code}\` is TypeScript. The import reads a structure file as plain JavaScript and fails on it: remove it (tracker CONV-parseJsx.ts:1845).`;
+const FREE_CODE = 'The import refuses this statement: a structure file holds only imports, `const` / `let` / `var` declarations and `export const Structure = () => …`.';
+const STRUCTURE_SHAPE = 'Declare Structure once, as `export const Structure = () => ( <Page …/> )`: an exported const arrow that returns the root element directly, with no `{ return … }`, fragment or condition around it.';
+const typeScript = (code) => `\`${code}\` is TypeScript. The import reads a structure file as plain JavaScript and fails on it: remove it.`;
 /** Every statement type but ImportDeclaration (always allowed) and the TypeScript ones (TYPESCRIPT). */
 const STATEMENTS = [
     'ExpressionStatement', 'ExportNamedDeclaration', 'ExportDefaultDeclaration', 'ExportAllDeclaration', 'VariableDeclaration',

package/dist/rules/site-app/page-structure.js

@@ -78,7 +78,7 @@ function hasRoot({ rulesApi, report }) {
     if (rulesApi.page.kind === 'page')
         report({ check: 'missing_root', loc: FILE_START, message: 'A page must start with <Page>, found nothing.' });
     else
-        report({ check: 'missing_root', loc: FILE_START, message: 'A global component must start with a section (HeaderSection, FooterSection or Section), found nothing (tracker CONV-runValidation.ts:9).' });
+        report({ check: 'missing_root', loc: FILE_START, message: 'A global component must start with a section (HeaderSection, FooterSection or Section), found nothing.' });
 }
 /** On a global component, reports a top element that isn't a section (P1-R13); the steps after it are for a section. */
 function isSectionAtTop({ node, rulesApi, report }) {
@@ -87,7 +87,7 @@ function isSectionAtTop({ node, rulesApi, report }) {
     const type = rulesApi.getType(node);
     if (isLandmark(node, rulesApi) || (type && SECTIONS.includes(type)))
         return true;
-    report({ check: 'invalid_global_root', loc: getLoc(node, rulesApi), message: `${describeElement(node, rulesApi)} sits directly in the master page. A global component's top element is a section (HeaderSection, FooterSection or Section); put it inside one (rule P1-R13).` });
+    report({ check: 'invalid_global_root', loc: getLoc(node, rulesApi), message: `${describeElement(node, rulesApi)} sits directly in the master page. A global component's top element is a section (HeaderSection, FooterSection or Section); put it inside one.` });
     return false;
 }
 /** Reports a root element with no string id (CONV-runValidation.ts:9). The tree steps go on: the import reports them all in one run. */
@@ -100,7 +100,7 @@ function rootHasId({ node, rulesApi, report }) {
         && attribute.value.expression.name === 'id') && receivesInstanceId(node))
         return;
     const tag = rulesApi.getTagName(node);
-    report({ check: 'missing_root_id', loc: getLoc(node, rulesApi), message: `<${tag}> at the top has no id. Give the root element its id, like \`<${tag} id="c1dmp">\` (tracker CONV-runValidation.ts:9).` });
+    report({ check: 'missing_root_id', loc: getLoc(node, rulesApi), message: `<${tag}> at the top has no id. Give the root element its id, like \`<${tag} id="c1dmp">\`.` });
 }
 /** Reports a page's root that isn't <Page>. */
 function startsWithPage({ node, rulesApi, report }) {
@@ -114,7 +114,7 @@ function checkPageChildren({ node: page, rulesApi, report }) {
     for (const child of getStructuralChildren(page, rulesApi)) {
         if (child.type === 'JSXElement')
             continue;
-        report({ check: 'non_element_child', loc: getLoc(page, rulesApi), message: `<Page> has ${describe(child, rulesApi)} as a child. Only elements go directly inside <Page>: a section, or a component pinned to the page (tracker CONV-parseJsx.ts:1668).` });
+        report({ check: 'non_element_child', loc: getLoc(page, rulesApi), message: `<Page> has ${describe(child, rulesApi)} as a child. Only elements go directly inside <Page>: a section, or a component pinned to the page.` });
     }
 }
 /** Reports a section, anywhere in the file, that doesn't hold exactly one <InternalContainer>, and nothing else (S2-SECTION-001, OUR-001). A wrapper in it
@@ -127,7 +127,7 @@ function hasOneInternalContainer(section, { rulesApi, report }) {
     if (inside.length === 1 && inside[0].type === 'JSXElement' && rulesApi.getType(inside[0]) === 'innerElement')
         return;
     const name = rulesApi.getId(section) ?? `<${rulesApi.getTagName(section)}>`;
-    report({ check: 'invalid_section_container', loc: getLoc(section, rulesApi), message: `Section ${name} must contain exactly one <InternalContainer>, found: ${inside.map((child) => describe(child, rulesApi)).join(', ') || 'nothing'}. Put the section's content inside its one <InternalContainer> (rule S2-SECTION-001).` });
+    report({ check: 'invalid_section_container', loc: getLoc(section, rulesApi), message: `Section ${name} must contain exactly one <InternalContainer>, found: ${inside.map((child) => describe(child, rulesApi)).join(', ') || 'nothing'}. Put the section's content inside its one <InternalContainer>.` });
 }
 /** Reports a <Page> held by another element (P1-R16), unless the root steps above report that placement already (a section's children). */
 function isNotNestedPage({ node, rulesApi, report }) {
@@ -136,7 +136,7 @@ function isNotNestedPage({ node, rulesApi, report }) {
     const holder = getHolder(node, rulesApi);
     if (!holder || (rulesApi.getType(holder) !== 'page' && isRootTreeHolder(holder, rulesApi) && isStructuralChild(holder, node, rulesApi)))
         return;
-    report({ check: 'nested_page', loc: getLoc(node, rulesApi), message: `${describeElement(node, rulesApi)} is inside ${describeElement(holder, rulesApi)}. A page is only the top element of its own page (rule P1-R16).` });
+    report({ check: 'nested_page', loc: getLoc(node, rulesApi), message: `${describeElement(node, rulesApi)} is inside ${describeElement(holder, rulesApi)}. A page is only the top element of its own page.` });
 }
 /** Reports a header or footer, or a page's reference to the global one, with an <InternalContainer> among its ancestors (P1-R03). */
 function isOutsideInternalContainers({ node, rulesApi, report }) {
@@ -146,20 +146,20 @@ function isOutsideInternalContainers({ node, rulesApi, report }) {
     const container = getAncestors(node).find((ancestor) => rulesApi.getType(ancestor) === 'innerElement');
     if (!container)
         return;
-    report({ check: 'landmark_inside_container', loc: getLoc(node, rulesApi), message: `The ${kind} ${describeElement(node, rulesApi)} is inside the internal container ${describeElement(container, rulesApi)}. Move it out of every internal container: the header and footer sit directly in the page or the master page (rule P1-R03).` });
+    report({ check: 'landmark_inside_container', loc: getLoc(node, rulesApi), message: `The ${kind} ${describeElement(node, rulesApi)} is inside the internal container ${describeElement(container, rulesApi)}. Move it out of every internal container: the header and footer sit directly in the page or the master page.` });
 }
 /** Reports a wrapper that doesn't hold exactly one element: none, two, text, or a {…} (a comment too) beside it (CONV-parseJsx.ts:1028). */
 function holdsOneElement({ node, rulesApi, report }) {
     if (holdsOne(node))
         return;
-    report({ check: 'invalid_wrapper_children', loc: node.openingElement.name.loc, message: `<${rulesApi.getTagName(node)}> wraps exactly one component element: give each component its own wrapper (tracker CONV-parseJsx.ts:1028).` });
+    report({ check: 'invalid_wrapper_children', loc: node.openingElement.name.loc, message: `<${rulesApi.getTagName(node)}> wraps exactly one component element: give each component its own wrapper.` });
 }
 /** Reports a <Remove> right inside another <Remove> (CONV-parseJsx.ts:1237): <Remove> wraps the component itself, so nothing nests in it. Compared with the element right around it, as the import does. */
 function checkNoRemoveInRemove({ node, rulesApi, report }) {
     const outer = getAncestors(node)[0];
     if (!outer || rulesApi.getType(outer) !== 'remove')
         return;
-    report({ check: 'nested_remove', loc: node.openingElement.name.loc, message: `<${rulesApi.getTagName(node)}> is inside another <Remove>. <Remove> wraps the component itself: merge the two conditions into one <Remove> (tracker CONV-parseJsx.ts:1237).` });
+    report({ check: 'nested_remove', loc: node.openingElement.name.loc, message: `<${rulesApi.getTagName(node)}> is inside another <Remove>. <Remove> wraps the component itself: merge the two conditions into one <Remove>.` });
 }
 /** Reports text, a {…} (a comment too), a fragment or a spread between a component's tags (CONV-parseJsx.ts:1668). The root steps report those in <Page> and its sections, except comments, which they don't see. */
 function hasOnlyElements({ node, rulesApi, report }) {
@@ -169,7 +169,7 @@ function hasOnlyElements({ node, rulesApi, report }) {
             continue;
         if (commentsOnly && !isComment(child))
             continue;
-        report({ check: 'non_element_child', loc: child.type === 'JSXText' ? getTextLoc(child) : child.loc, message: `${describeElement(node, rulesApi)} has text or {…} as a child. Put the value in an attribute: only elements go between the tags (tracker CONV-parseJsx.ts:1668).` });
+        report({ check: 'non_element_child', loc: child.type === 'JSXText' ? getTextLoc(child) : child.loc, message: `${describeElement(node, rulesApi)} has text or {…} as a child. Put the value in an attribute: only elements go between the tags.` });
     }
 }
 /** Reports an <InternalContainer>'s or a <Page>'s layer that isn't an array literal of elements (CONV-parseJsx.ts:1630). */
@@ -182,7 +182,7 @@ function hasLayerArrays({ node, rulesApi, report }) {
             continue;
         if (isArrayOfElements(attribute))
             continue;
-        report({ check: 'invalid_element_array', loc: attribute.loc, message: `${describeElement(node, rulesApi)}'s ${attribute.name.name} must be an array of elements: ${attribute.name.name}={[<… />]} (tracker CONV-parseJsx.ts:1630).` });
+        report({ check: 'invalid_element_array', loc: attribute.loc, message: `${describeElement(node, rulesApi)}'s ${attribute.name.name} must be an array of elements: ${attribute.name.name}={[<… />]}.` });
     }
 }
 /** A <PinnedToScreen>: no props, one element held, a pinnable one, in its <Page> slot. */