@wix/origami-lint 1.34.19 → 1.34.21

package/dist/rules/site-app/bindings.js

@@ -1,5 +1,6 @@
 import { BUILDERS, CALLBACK_PROP, EVENT_ATTRIBUTE, RESERVED_ENTRY_KEYS, RUNTIME_PACKAGE, TRANSFORM_BUILDERS, TYPED_BUILDERS, bare, getAttribute, getExpression, getKey, getCallbackKind, getName, getObject, getParamReadKind, getProperties, getProperty, isBound, isReservedAttribute, isStructure, ownerOf, } from "../../rules-api/index.js";
 import { defineRule } from "./define-rule.js";
+const CHECKS = ['invalid_svg_expression', 'missing_remove_condition', 'invalid_remove_condition', 'duplicate_remove_condition', 'nested_binding_builder', 'callback_attribute', 'non_function_callback', 'duplicate_binding', 'invalid_bindings_object', 'removed_in_raw_bindings', 'invalid_raw_properties', 'static_binding_value', 'builder_as_bindings', 'invalid_bindings_key', 'removed_in_bindings', 'state_in_bindings', 'invalid_binding_map', 'invalid_binding_map_entry', 'unknown_visibility', 'array_binding_value', 'array_condition', 'invalid_binding_value', 'invalid_binding_placement', 'invalid_method_target', 'spread_builder_arguments', 'duplicate_builder_key', 'invalid_context_arguments', 'missing_function_argument', 'invalid_callback_target', 'invalid_placeholder', 'invalid_comparison_arguments', 'literal_comparison_binding', 'invalid_comparison_value', 'invalid_raw_bindings_type', 'insufficient_conditions', 'invalid_raw_arguments', 'call_in_raw', 'non_object_raw', 'non_literal_raw', 'invalid_builder_import', 'non_identifier_binding_name', 'invalid_binding_import', 'missing_context_name'];
 /** The converter's reserved sources (identity.ts `isReservedRegistry`) and the DM's own `document`: no fn()/ctx() names. */
 const RESERVED_FOR_BINDINGS = ['runtime', 'interactReact', 'interact', 'motionPresets', 'menu', 'document', 'core'];
 /** The key of a `bindings` object (parseJsx.ts bindingsIrOfExpression); the other two sections are written in `className` since converter 0.79. */
@@ -27,6 +28,7 @@ const PLAIN = 'a string, number or true / false';
 const RENDER_BUILDERS = ['ctx', 'fn', ...TRANSFORM_BUILDERS];
 export default defineRule({
     name: 'bindings',
+    checks: CHECKS,
     editors: ['studio2'],
     callbacks: {
         JSXElement: checkJSXElementBindings,
@@ -117,7 +119,7 @@ function checkSvgArguments({ node, rulesApi, report }) {
                 return;
         }
     }
-    report({
+    report({ check: 'invalid_svg_expression',
         loc: node.loc,
         message: tracked("An SVG media expression must be `svg(media.getShapeUrl('wix:image://v1/<uri>').url, '<uri>')`, with matching URI strings, svg imported from '@wix/origami-runtime' and media from '@wix/sdk'.", 'CONV-vectorArtExpression.ts:44'),
     });
@@ -125,20 +127,20 @@ function checkSvgArguments({ node, rulesApi, report }) {
 /** Each builder's own row: the shape of its call, a key written twice in it. */
 const ROW_OF_BUILDER = { all: 'CONV-decode.ts:196', callback: 'CONV-astValue.ts:287', ctx: 'CONV-astValue.ts:276', fn: 'CONV-astValue.ts:287', is: 'CONV-decode.ts:172', raw: 'CONV-decode.ts:28' };
 const tracked = (message, row) => `${message.slice(0, -1)} (tracker ${row}).`;
-const say = ({ input }, node, message, row) => input.report({ loc: node.loc, message: tracked(message, row) });
+const say = ({ input }, node, check, message, row) => input.report({ check, loc: node.loc, message: tracked(message, row) });
 const textOf = ({ input }, node) => input.context.sourceCode.getText(node);
 const describeIn = (at, node) => describe(node, (part) => textOf(at, part));
 function removeWhen(at) {
     const { node } = at.input;
     const when = getAttribute(node, 'when');
     if (!when) {
-        say(at, node.openingElement.name, `${at.owner} needs \`when={…}\`: the condition that removes the component it wraps.`, 'CONV-parseJsx.ts:1113');
+        say(at, node.openingElement.name, 'missing_remove_condition', `${at.owner} needs \`when={…}\`: the condition that removes the component it wraps.`, 'CONV-parseJsx.ts:1113');
         return null;
     }
     const value = getExpression(when);
     const what = when.value ? `\`${at.input.context.sourceCode.getText(when.value)}\`` : 'empty';
     if (!value)
-        say(at, when, `\`when\` on ${at.owner} is ${what}. Write the condition in braces: \`when={…}\`.`, 'CONV-parseJsx.ts:1113');
+        say(at, when, 'invalid_remove_condition', `\`when\` on ${at.owner} is ${what}. Write the condition in braces: \`when={…}\`.`, 'CONV-parseJsx.ts:1113');
     return value;
 }
 function removeTarget(at) {
@@ -151,28 +153,28 @@ function removeTarget(at) {
         const item = getObject(value.arguments[0]);
         // An item of another type is the bindings' own line (checkRawBindingsType).
         if (item && stringValue(getProperty(item, 'type')?.value) === BINDINGS_LIST && setsRemoved(item)) {
-            say(at, value, `${at.owner} wraps ${ownerOf(component)}, whose \`bindings\` are \`raw()\` of an item that already sets \`features.visibility.${REMOVED}\`. Keep only one of them.`, 'CONV-decode.ts:280');
+            say(at, value, 'duplicate_remove_condition', `${at.owner} wraps ${ownerOf(component)}, whose \`bindings\` are \`raw()\` of an item that already sets \`features.visibility.${REMOVED}\`. Keep only one of them.`, 'CONV-decode.ts:280');
         }
     }
 }
 function builderInPlace(at) {
     const { node, rulesApi } = at.input;
     for (const [call, where] of misplacedBuilders(node, rulesApi)) {
-        say(at, call, `\`${builderOf(call, rulesApi)}()\` on ${at.owner} is inside ${where}, where the import reads only plain values. Write a builder as the whole value of a data attribute (\`label={ctx(…)}\`) or of an elementProps entry key (\`navbar: { label: ctx(…) }\`), or in \`bindings\`.`, 'CONV-astValue.ts:98');
+        say(at, call, 'nested_binding_builder', `\`${builderOf(call, rulesApi)}()\` on ${at.owner} is inside ${where}, where the import reads only plain values. Write a builder as the whole value of a data attribute (\`label={ctx(…)}\`) or of an elementProps entry key (\`navbar: { label: ctx(…) }\`), or in \`bindings\`.`, 'CONV-astValue.ts:98');
     }
 }
 /** A callback prop takes a function: the import reads it only in `bindings.props`, and there the site's runtime throws on anything but `callback()` (withOrigami). */
 function checkCallbackProps(at) {
     const { node, rulesApi } = at.input;
     for (const [name, attribute] of getCallbackAttributes(node)) {
-        say(at, attribute, `\`${name}\` on ${at.owner} is an attribute, which the import doesn't read for a callback prop. Bind it in \`bindings\` with \`callback()\`: \`bindings={{ props: { ${name}: callback(goHome) } }}\`.`, 'OUR-031');
+        say(at, attribute, 'callback_attribute', `\`${name}\` on ${at.owner} is an attribute, which the import doesn't read for a callback prop. Bind it in \`bindings\` with \`callback()\`: \`bindings={{ props: { ${name}: callback(goHome) } }}\`.`, 'OUR-031');
     }
     if (!isWrappedByRuntime(node, rulesApi))
         return;
     for (const [name, value] of getBoundCallbacks(getAttribute(node, 'bindings'))) {
         const what = runsAtRender(at, value);
         if (what)
-            say(at, value, `\`bindings.props.${name}\` on ${at.owner} is ${what}, which runs at render and gives a value, not a function: the site's runtime throws on it. Write \`${name}: callback(goHome)\`.`, 'OUR-031');
+            say(at, value, 'non_function_callback', `\`bindings.props.${name}\` on ${at.owner} is ${what}, which runs at render and gives a value, not a function: the site's runtime throws on it. Write \`${name}: callback(goHome)\`.`, 'OUR-031');
     }
 }
 function boundPropOnce(at) {
@@ -184,7 +186,7 @@ function boundPropOnce(at) {
     for (const [name, attribute] of boundAttributes(node, rulesApi)) {
         const where = props.raw ? `bindings={raw({ properties: { ${name} } })}` : `bindings={{ props: { ${name} } }}`;
         if (props.names.has(name))
-            say(at, attribute, `${at.owner} binds \`${name}\` twice: in \`${name}={…}\` and in \`${where}\`. Keep one.`, 'CONV-parseJsx.ts:753');
+            say(at, attribute, 'duplicate_binding', `${at.owner} binds \`${name}\` twice: in \`${name}={…}\` and in \`${where}\`. Keep one.`, 'CONV-parseJsx.ts:753');
     }
 }
 function entryPropBoundOnce(at, entry) {
@@ -194,7 +196,7 @@ function entryPropBoundOnce(at, entry) {
     for (const [key, property] of boundEntryKeys(entry, at.input.rulesApi)) {
         const where = props.raw ? `bindings: raw({ properties: { ${key} } })` : `bindings.props.${key}`;
         if (props.names.has(key))
-            say(at, property, `${at.owner} binds \`${key}\` twice: in \`${key}: …\` and in its \`${where}\`. Keep one.`, 'CONV-parseJsx.ts:753');
+            say(at, property, 'duplicate_binding', `${at.owner} binds \`${key}\` twice: in \`${key}: …\` and in its \`${where}\`. Keep one.`, 'CONV-parseJsx.ts:753');
     }
 }
 function bindingsAttribute(at, attribute) {
@@ -204,7 +206,7 @@ function bindingsAttribute(at, attribute) {
     if (value)
         bindingsValue(at, value);
     else
-        say(at, attribute, notBindings(at, attribute.value ? `\`${at.input.context.sourceCode.getText(attribute.value)}\`` : 'empty'), 'CONV-parseJsx.ts:700');
+        say(at, attribute, 'invalid_bindings_object', notBindings(at, attribute.value ? `\`${at.input.context.sourceCode.getText(attribute.value)}\`` : 'empty'), 'CONV-parseJsx.ts:700');
 }
 const notBindings = (at, what) => `\`bindings\` on ${at.owner} is ${what}. Write an object in place, \`bindings={{ props: {…} }}\`, or \`raw({…})\`.`;
 function bindingsValue(at, node, isEntry = false) {
@@ -220,21 +222,21 @@ function bindingsValue(at, node, isEntry = false) {
         if (!isEntry)
             checkRawBindingsType(at, value, object);
         if (!isEntry && setsRemoved(object))
-            say(at, value, `${at.owner} sets \`features.visibility.${REMOVED}\` in its \`raw()\` bindings. Move the condition out, and wrap the component in \`<Remove when={…}>\`.`, 'CONV-decode.ts:280');
+            say(at, value, 'removed_in_raw_bindings', `${at.owner} sets \`features.visibility.${REMOVED}\` in its \`raw()\` bindings. Move the condition out, and wrap the component in \`<Remove when={…}>\`.`, 'CONV-decode.ts:280');
         const propertyMap = getProperty(object, 'properties');
         const properties = getObject(propertyMap?.value);
         if (propertyMap && !properties)
-            say(at, propertyMap.value, `The \`properties\` in \`raw()\` bindings on ${at.owner} isn't an object. Write a prop map of typed bindings: \`properties: { label: { type: 'ContextBinding', … } }\`.`, 'CONV-decode.ts:252');
+            say(at, propertyMap.value, 'invalid_raw_properties', `The \`properties\` in \`raw()\` bindings on ${at.owner} isn't an object. Write a prop map of typed bindings: \`properties: { label: { type: 'ContextBinding', … } }\`.`, 'CONV-decode.ts:252');
         for (const property of properties ? getProperties(properties) : []) {
             if (isStaticItem(property.value))
-                say(at, property.value, fixedValue(at, getKey(property)), 'CONV-decode.ts:252');
+                say(at, property.value, 'static_binding_value', fixedValue(at, getKey(property)), 'CONV-decode.ts:252');
         }
     }
     else if (builder) {
-        say(at, value, `\`bindings\` on ${at.owner} is a \`${builder}()\` call. Write an object and put the call under props, or use \`raw({…})\`.`, 'CONV-decode.ts:263');
+        say(at, value, 'builder_as_bindings', `\`bindings\` on ${at.owner} is a \`${builder}()\` call. Write an object and put the call under props, or use \`raw({…})\`.`, 'CONV-decode.ts:263');
     }
     else if (!isCallByName(value)) {
-        say(at, value, notBindings(at, describeIn(at, value)), 'CONV-parseJsx.ts:700');
+        say(at, value, 'invalid_bindings_object', notBindings(at, describeIn(at, value)), 'CONV-parseJsx.ts:700');
     }
 }
 function bindingsObject(at, bindings, isEntry) {
@@ -246,7 +248,7 @@ function bindingsObject(at, bindings, isEntry) {
                         : property.key.name === BINDINGS_KEY || CLASS_NAME_SECTIONS.includes(property.key.name) ? null
                             : `the key \`${property.key.name}\``;
         if (what)
-            say(at, property, `\`bindings\` on ${at.owner} has ${what}. Use only the key props, written as a plain name.`, 'CONV-parseJsx.ts:708');
+            say(at, property, 'invalid_bindings_key', `\`bindings\` on ${at.owner} has ${what}. Use only the key props, written as a plain name.`, 'CONV-parseJsx.ts:708');
         else if (getKey(property) === BINDINGS_KEY)
             section(at, BINDINGS_KEY, property.value);
         else
@@ -258,16 +260,16 @@ function classNameSection(at, property, isEntry) {
     const key = getKey(property);
     const removed = key === 'visibility' && !isEntry && getObject(property.value) && getProperty(getObject(property.value), REMOVED);
     if (removed)
-        return say(at, removed, `${at.owner} sets \`visibility.${REMOVED}\` in its \`bindings\`. Move the condition out, and wrap the component in \`<Remove when={…}>\`.`, 'CONV-decode.ts:280');
+        return say(at, removed, 'removed_in_bindings', `${at.owner} sets \`visibility.${REMOVED}\` in its \`bindings\`. Move the condition out, and wrap the component in \`<Remove when={…}>\`.`, 'CONV-decode.ts:280');
     const term = key === 'states' ? '{ hover: is(…) }' : "{ 'wix-visibility-hidden': is(…) }";
     const fix = isEntry ? `in the entry's \`className: ${term}\`` : `as a \`className\` term: \`className={['comp-x', ${term}]}\``;
-    say(at, property, `\`bindings.${key}\` on ${at.owner} isn't read: the import reads states and visibility in \`className\`. Write each condition ${fix}.`, 'CONV-parseJsx.ts:708');
+    say(at, property, 'state_in_bindings', `\`bindings.${key}\` on ${at.owner} isn't read: the import reads states and visibility in \`className\`. Write each condition ${fix}.`, 'CONV-parseJsx.ts:708');
 }
 function section(at, name, node) {
     const fix = `Write an object of \`key: value\` entries: \`${name}: { label: … }\`.`;
     const value = bare(node);
     if (value.type !== 'ObjectExpression')
-        return say(at, value, `\`bindings.${name}\` on ${at.owner} isn't an object. ${fix}`, 'CONV-parseJsx.ts:669');
+        return say(at, value, 'invalid_binding_map', `\`bindings.${name}\` on ${at.owner} isn't an object. ${fix}`, 'CONV-parseJsx.ts:669');
     for (const property of value.properties) {
         const problem = property.type === 'SpreadElement' ? 'has a spread'
             : property.computed ? 'has a computed key'
@@ -277,7 +279,7 @@ function section(at, name, node) {
                             : getKey(property) === null ? `has the key \`${textOf(at, property.key)}\``
                                 : null;
         if (problem) {
-            say(at, property, `\`bindings.${name}\` on ${at.owner} ${problem}. ${fix}`, 'CONV-parseJsx.ts:669');
+            say(at, property, 'invalid_binding_map_entry', `\`bindings.${name}\` on ${at.owner} ${problem}. ${fix}`, 'CONV-parseJsx.ts:669');
             continue;
         }
         prop(at, getKey(property), property.value, false);
@@ -299,7 +301,7 @@ function classNameConditions(at, terms, where) {
         if (key === null)
             continue;
         if (key.startsWith(VISIBILITY_PREFIX) && !VISIBILITY_KEYS.includes(key.slice(VISIBILITY_PREFIX.length))) {
-            say(at, property, `${where} on ${at.owner} has the term \`${key}\`, which isn't a visibility. Use \`${VISIBILITY_PREFIX}hidden\` or \`${VISIBILITY_PREFIX}collapsed\`.`, 'CONV-decode.ts:221');
+            say(at, property, 'unknown_visibility', `${where} on ${at.owner} has the term \`${key}\`, which isn't a visibility. Use \`${VISIBILITY_PREFIX}hidden\` or \`${VISIBILITY_PREFIX}collapsed\`.`, 'CONV-decode.ts:221');
         }
         else
             condition(at, property.value, `${where} term \`${key}\``);
@@ -308,9 +310,9 @@ function classNameConditions(at, terms, where) {
 function prop(at, name, node, placeholderAllowed) {
     const value = bare(node);
     if (value.type === 'ArrayExpression')
-        return say(at, value, `\`bindings.props.${name}\` on ${at.owner} is an array. Bind the prop to one value: \`ctx()\`, \`fn()\` or \`raw()\`.`, 'CONV-decode.ts:209');
+        return say(at, value, 'array_binding_value', `\`bindings.props.${name}\` on ${at.owner} is an array. Bind the prop to one value: \`ctx()\`, \`fn()\` or \`raw()\`.`, 'CONV-decode.ts:209');
     if (isPlain(value) || rawOnly(value) || isStaticRaw(at, value) || isTyped(value, at.input.rulesApi))
-        return say(at, value, fixedValue(at, name), 'CONV-decode.ts:252');
+        return say(at, value, 'static_binding_value', fixedValue(at, name), 'CONV-decode.ts:252');
     binding(at, value, 'prop', placeholderAllowed);
 }
 const fixedValue = (at, name) => `\`${name}\` on ${at.owner} is bound to a fixed value. Write it as the attribute \`${name}=…\`, or as an \`fn()\` argument.`;
@@ -326,7 +328,7 @@ function condition(at, node, where, inRemove = false) {
         return binding(at, value, 'condition');
     if (inRemove || value.elements.length > 0) {
         const spread = hasHoleOrSpread(value);
-        say(at, value, `${where} on ${at.owner} is ${spread ? 'a list with a spread or an empty place' : 'a list'}. Write one condition, or \`all(a, b, …)\`.`, spread ? 'CONV-parseJsx.ts:655' : 'CONV-decode.ts:190');
+        say(at, value, 'array_condition', `${where} on ${at.owner} is ${spread ? 'a list with a spread or an empty place' : 'a list'}. Write one condition, or \`all(a, b, …)\`.`, spread ? 'CONV-parseJsx.ts:655' : 'CONV-decode.ts:190');
     }
 }
 function binding(at, node, place, placeholderAllowed = false) {
@@ -356,27 +358,27 @@ function binding(at, node, place, placeholderAllowed = false) {
     if (raw === 'an object' && place === 'fnArg' && isDataItem(value))
         return;
     if (raw === 'an object' && place === 'fnArg')
-        return say(at, value, `${capitalize(name)} on ${at.owner} is an object that isn't a data item. Write ${PLAIN}, a link (\`{ href: … }\`) or a typed item (\`{ type: 'Builder.Image', … }\`), or wrap it in \`raw()\`.`, 'CONV-decode.ts:86');
+        return say(at, value, 'invalid_binding_value', `${capitalize(name)} on ${at.owner} is an object that isn't a data item. Write ${PLAIN}, a link (\`{ href: … }\`) or a typed item (\`{ type: 'Builder.Image', … }\`), or wrap it in \`raw()\`.`, 'CONV-decode.ts:86');
     if (raw)
-        return say(at, value, `${capitalize(name)} on ${at.owner} is ${raw}. Write ${PLAIN}, or wrap it in \`raw()\`.`, 'CONV-decode.ts:86');
-    say(at, value, `${capitalize(name)} on ${at.owner} is ${describeIn(at, value)}. Write it out. ${hintFor(place)}`, 'CONV-decode.ts:86');
+        return say(at, value, 'invalid_binding_value', `${capitalize(name)} on ${at.owner} is ${raw}. Write ${PLAIN}, or wrap it in \`raw()\`.`, 'CONV-decode.ts:86');
+    say(at, value, 'invalid_binding_value', `${capitalize(name)} on ${at.owner} is ${describeIn(at, value)}. Write it out. ${hintFor(place)}`, 'CONV-decode.ts:86');
 }
-const wrongPlace = (at, node, what, place) => say(at, node, `${capitalize(what)} can't be ${PLACES[place].name} on ${at.owner}. ${hintFor(place)}`, 'CONV-decode.ts:126');
+const wrongPlace = (at, node, what, place) => say(at, node, 'invalid_binding_placement', `${capitalize(what)} can't be ${PLACES[place].name} on ${at.owner}. ${hintFor(place)}`, 'CONV-decode.ts:126');
 /** A called ctx() or row member: `ctx('cart.add', { from: useCart })(item.id)`, `item.actions.select('quick')` (decode.ts decodeInvoke). */
 function invoke(at, node) {
     const { callee } = node;
     if (!isMethodTarget(callee, at.input.rulesApi))
-        return say(at, node, `${capitalize(describeIn(at, node))} on ${at.owner} calls what isn't a context or the renderItem row. Call only \`ctx(…)\` or a member of the row: \`ctx('cart.add', { from: useCart })(item.id)\`.`, 'CONV-decode.ts:86');
+        return say(at, node, 'invalid_method_target', `${capitalize(describeIn(at, node))} on ${at.owner} calls what isn't a context or the renderItem row. Call only \`ctx(…)\` or a member of the row: \`ctx('cart.add', { from: useCart })(item.id)\`.`, 'CONV-decode.ts:86');
     if (callee.type === 'CallExpression')
         ctxCall(at, callee, false);
     if (node.arguments.some((argument) => argument.type === 'SpreadElement'))
-        return say(at, node, `A called \`ctx()\` or row member on ${at.owner} spreads its arguments. Write each argument out.`, 'CONV-astValue.ts:310');
+        return say(at, node, 'spread_builder_arguments', `A called \`ctx()\` or row member on ${at.owner} spreads its arguments. Write each argument out.`, 'CONV-astValue.ts:310');
     for (const argument of node.arguments)
         binding(at, argument, 'fnArg');
 }
 function call(at, node, builder, place, placeholderAllowed) {
     if (node.arguments.some((argument) => argument.type === 'SpreadElement')) {
-        return say(at, node, `\`${builder}()\` on ${at.owner} spreads its arguments. Write each argument out.`, 'CONV-astValue.ts:310');
+        return say(at, node, 'spread_builder_arguments', `\`${builder}()\` on ${at.owner} spreads its arguments. Write each argument out.`, 'CONV-astValue.ts:310');
     }
     // map() and shape() hold a callback, read in its own scope: no tracker row checks its shape yet.
     if (builder === 'map' || builder === 'shape' || hasDuplicateKey(at, node, builder))
@@ -397,7 +399,7 @@ function call(at, node, builder, place, placeholderAllowed) {
 function hasDuplicateKey(at, node, builder) {
     const twice = node.arguments.map(duplicateKeyIn).find(Boolean);
     if (twice)
-        say(at, twice, `\`${builder}()\` on ${at.owner} has the key \`${getKey(twice)}\` twice. Keep one.`, ROW_OF_BUILDER[builder]);
+        say(at, twice, 'duplicate_builder_key', `\`${builder}()\` on ${at.owner} has the key \`${getKey(twice)}\` twice. Keep one.`, ROW_OF_BUILDER[builder]);
     return Boolean(twice);
 }
 function ctxCall(at, node, placeholderAllowed) {
@@ -414,7 +416,7 @@ function ctxCall(at, node, placeholderAllowed) {
                             : keys.includes('placeholder') && !placeholderAllowed ? 'has a placeholder: only a whole attribute value, or an elementProps entry value, has one'
                                 : null;
     if (problem)
-        return say(at, node, `\`ctx()\` on ${at.owner} ${problem}. Write \`ctx('item.path', { from: useX })\`.`, 'CONV-astValue.ts:276');
+        return say(at, node, 'invalid_context_arguments', `\`ctx()\` on ${at.owner} ${problem}. Write \`ctx('item.path', { from: useX })\`.`, 'CONV-astValue.ts:276');
     const placeholder = object && getProperty(object, 'placeholder');
     if (placeholder)
         placeholderValue(at, placeholder.value);
@@ -422,7 +424,7 @@ function ctxCall(at, node, placeholderAllowed) {
 function fnCall(at, node, placeholderAllowed) {
     const [, ...rest] = node.arguments;
     if (node.arguments.length === 0)
-        return say(at, node, `\`fn()\` on ${at.owner} has no arguments. Write the imported function first: \`fn(numberToText, …)\`.`, 'CONV-astValue.ts:287');
+        return say(at, node, 'missing_function_argument', `\`fn()\` on ${at.owner} has no arguments. Write the imported function first: \`fn(numberToText, …)\`.`, 'CONV-astValue.ts:287');
     const last = rest.at(-1);
     const options = placeholderAllowed && last ? getObject(last) : null;
     const placeholder = options && options.properties.length === 1 ? getProperty(options, 'placeholder') : undefined;
@@ -437,12 +439,12 @@ function fnCall(at, node, placeholderAllowed) {
 function callbackCall(at, node) {
     const [first, ...bound] = node.arguments;
     if (!first)
-        return say(at, node, `\`callback()\` on ${at.owner} has no arguments. Write the function first: \`callback(goHome, …)\`.`, 'CONV-astValue.ts:287');
+        return say(at, node, 'missing_function_argument', `\`callback()\` on ${at.owner} has no arguments. Write the function first: \`callback(goHome, …)\`.`, 'CONV-astValue.ts:287');
     const target = bare(first);
     // A name that isn't a parameter is the imported function: bindingNameImported checks its import.
     const isFunctionName = target.type === 'Identifier' && !getParamReadKind(target);
     if (!isFunctionName && !isMethodTarget(target, at.input.rulesApi))
-        return say(at, target, `\`callback()\`'s function on ${at.owner} is ${describeIn(at, target)}. Write an imported function, a \`ctx()\` or a member of the renderItem row: \`callback(goHome, …)\`.`, 'CONV-decode.ts:86');
+        return say(at, target, 'invalid_callback_target', `\`callback()\`'s function on ${at.owner} is ${describeIn(at, target)}. Write an imported function, a \`ctx()\` or a member of the renderItem row: \`callback(goHome, …)\`.`, 'CONV-decode.ts:86');
     if (target.type === 'CallExpression')
         ctxCall(at, target, false);
     for (const argument of bound)
@@ -451,20 +453,20 @@ function callbackCall(at, node) {
 function placeholderValue(at, node) {
     const value = bare(node);
     if (!isPlain(value))
-        say(at, value, `The placeholder on ${at.owner} is ${rawOnly(value) ?? describeIn(at, value)}. Write ${PLAIN}.`, 'CONV-parseJsx.ts:729');
+        say(at, value, 'invalid_placeholder', `The placeholder on ${at.owner} is ${rawOnly(value) ?? describeIn(at, value)}. Write ${PLAIN}.`, 'CONV-parseJsx.ts:729');
 }
 function isCall(at, node) {
     const fix = 'Write `is(<ctx() or fn()>, <string or true / false>)`.';
     if (node.arguments.length !== 2)
-        return say(at, node, `\`is()\` on ${at.owner} has ${node.arguments.length} argument${node.arguments.length === 1 ? '' : 's'}. ${fix}`, 'CONV-decode.ts:172');
+        return say(at, node, 'invalid_comparison_arguments', `\`is()\` on ${at.owner} has ${node.arguments.length} argument${node.arguments.length === 1 ? '' : 's'}. ${fix}`, 'CONV-decode.ts:172');
     const [binded, compared] = node.arguments.map((argument) => bare(argument));
     if (isPlain(binded) || rawOnly(binded) || builderOf(binded, at.input.rulesApi) === 'raw' || isTyped(binded, at.input.rulesApi))
-        say(at, binded, `\`is()\` on ${at.owner} compares ${isCallByName(binded) ? `\`${builderOf(binded, at.input.rulesApi)}()\`` : 'a literal'}, not a binding. ${fix}`, 'CONV-decode.ts:172');
+        say(at, binded, 'literal_comparison_binding', `\`is()\` on ${at.owner} compares ${isCallByName(binded) ? `\`${builderOf(binded, at.input.rulesApi)}()\`` : 'a literal'}, not a binding. ${fix}`, 'CONV-decode.ts:172');
     else
         binding(at, binded, 'isBinding');
     const isStringOrBoolean = compared.type === 'Literal' && ['string', 'boolean'].includes(typeof compared.value);
     if (!isStringOrBoolean)
-        say(at, compared, `\`is()\` on ${at.owner} compares to ${rawOnly(compared) ?? describeIn(at, compared)}. ${fix}`, 'CONV-decode.ts:172');
+        say(at, compared, 'invalid_comparison_value', `\`is()\` on ${at.owner} compares to ${rawOnly(compared) ?? describeIn(at, compared)}. ${fix}`, 'CONV-decode.ts:172');
 }
 /**
  * A component's `raw()` bindings are one item of the bindings namespace, and its one schema is BindingsList (reservedAttributes.ts
@@ -476,33 +478,33 @@ function checkRawBindingsType(at, node, item) {
     if (stringValue(type?.value) === BINDINGS_LIST)
         return;
     const has = type ? `has the type \`${textOf(at, type.value)}\`` : 'has no `type`';
-    say(at, type?.value ?? node, `The \`raw()\` bindings item on ${at.owner} ${has}. Write \`raw({ type: '${BINDINGS_LIST}', … })\`: the import stores no other bindings item.`, 'CONV-decode.ts:28');
+    say(at, type?.value ?? node, 'invalid_raw_bindings_type', `The \`raw()\` bindings item on ${at.owner} ${has}. Write \`raw({ type: '${BINDINGS_LIST}', … })\`: the import stores no other bindings item.`, 'CONV-decode.ts:28');
 }
 function allCall(at, node, place) {
     const count = node.arguments.length;
     if (place === 'condition' && count < 2)
-        say(at, node, `\`all()\` on ${at.owner} has ${count} condition${count === 1 ? '' : 's'}. Give it two or more, or write the one condition without \`all()\`.`, 'CONV-decode.ts:196');
+        say(at, node, 'insufficient_conditions', `\`all()\` on ${at.owner} has ${count} condition${count === 1 ? '' : 's'}. Give it two or more, or write the one condition without \`all()\`.`, 'CONV-decode.ts:196');
     for (const argument of node.arguments)
         binding(at, argument, 'allItem');
 }
 function isRawWrittenOut(at, node) {
     const [item, ...extra] = node.arguments;
     if (!item || extra.length > 0) {
-        say(at, node, `\`raw()\` on ${at.owner} has ${node.arguments.length} arguments. Write one item: \`raw({ type: …, … })\`.`, 'CONV-decode.ts:28');
+        say(at, node, 'invalid_raw_arguments', `\`raw()\` on ${at.owner} has ${node.arguments.length} arguments. Write one item: \`raw({ type: …, … })\`.`, 'CONV-decode.ts:28');
         return false;
     }
     const value = bare(item);
     if (value.type === 'CallExpression') {
-        say(at, value, `\`raw()\` on ${at.owner} wraps a call (\`${textOf(at, value)}\`). Write the item out as an object, or use the builder without \`raw()\`.`, 'CONV-decode.ts:28');
+        say(at, value, 'call_in_raw', `\`raw()\` on ${at.owner} wraps a call (\`${textOf(at, value)}\`). Write the item out as an object, or use the builder without \`raw()\`.`, 'CONV-decode.ts:28');
         return false;
     }
     if (value.type !== 'ObjectExpression') {
-        say(at, value, `\`raw()\` on ${at.owner} wraps ${rawOnly(value) ?? describeIn(at, value)}, not an object. Write one item: \`raw({ type: …, … })\`.`, 'CONV-decode.ts:28');
+        say(at, value, 'non_object_raw', `\`raw()\` on ${at.owner} wraps ${rawOnly(value) ?? describeIn(at, value)}, not an object. Write one item: \`raw({ type: …, … })\`.`, 'CONV-decode.ts:28');
         return false;
     }
     const found = nonLiteralIn(value);
     if (found)
-        say(at, found, `\`raw()\` on ${at.owner} holds ${describeIn(at, found)}. Write its item out with literal values.`, 'CONV-decode.ts:28');
+        say(at, found, 'non_literal_raw', `\`raw()\` on ${at.owner} holds ${describeIn(at, found)}. Write its item out with literal values.`, 'CONV-decode.ts:28');
     return !found;
 }
 /** Only BUILDERS: other runtime names (`Remove(…)`) pass the converter's parse, then its decode has no case for them. */
@@ -511,7 +513,7 @@ function isBuilderImported({ rulesApi, report }, callee) {
     if (found?.kind === 'runtime' && found.imported === callee.name && BUILDERS.includes(callee.name))
         return true;
     const builder = found?.kind === 'runtime' ? found.imported : callee.name;
-    report({
+    report({ check: 'invalid_builder_import',
         loc: callee.loc,
         message: tracked(BUILDERS.includes(builder)
             ? `\`${callee.name}(…)\` isn't the builder \`${builder}\` from ${RUNTIME_PACKAGE}. Import it under its own name, \`import { ${builder} } from '${RUNTIME_PACKAGE}'\`, and call it as \`${builder}(…)\`.`
@@ -530,7 +532,7 @@ function bindingNameImported({ node, rulesApi, report, context }, builder) {
     const value = bare(named);
     const what = builder === 'fn' ? "fn()'s function" : builder === 'callback' ? "callback()'s function" : "ctx()'s `from` hook";
     if (value.type !== 'Identifier') {
-        report({ loc: value.loc, message: tracked(`${what} is \`${context.sourceCode.getText(value)}\`. Write an imported name: \`fn(numberToText, …)\`, \`{ from: useProduct }\`.`, 'CONV-astValue.ts:227') });
+        report({ check: 'non_identifier_binding_name', loc: value.loc, message: tracked(`${what} is \`${context.sourceCode.getText(value)}\`. Write an imported name: \`fn(numberToText, …)\`, \`{ from: useProduct }\`.`, 'CONV-astValue.ts:227') });
         return null;
     }
     const found = rulesApi.getImport(value);
@@ -542,13 +544,13 @@ function bindingNameImported({ node, rulesApi, report, context }, builder) {
                 ? [`${what} \`${value.name}\` is a namespace (\`import * as ${value.name}\`). Import the ${builder === 'fn' ? 'function' : 'hook'} itself by name: \`import { name } from '${found.source}'\`.`, 'CONV-astValue.ts:227']
                 : null;
     if (problem)
-        report({ loc: value.loc, message: tracked(...problem) });
+        report({ check: 'invalid_binding_import', loc: value.loc, message: tracked(...problem) });
     return found && !problem && builder === 'ctx' ? { hook: value, source: found.source } : null;
 }
 function ctxSourceHasName({ report }, { hook, source }) {
     if (source.indexOf('/') !== source.length - 1)
         return;
-    report({ loc: hook.loc, message: tracked(`ctx()'s \`from\` hook \`${hook.name}\` is imported from '${source}', which has no context name after the \`/\`. Write '<componentType>/<contextName>'.`, 'CONV-decode.ts:100') });
+    report({ check: 'missing_context_name', loc: hook.loc, message: tracked(`ctx()'s \`from\` hook \`${hook.name}\` is imported from '${source}', which has no context name after the \`/\`. Write '<componentType>/<contextName>'.`, 'CONV-decode.ts:100') });
 }
 // ── reading the code ──
 function getElementPropsEntries(element) {

package/dist/rules/site-app/breakpoints.js

@@ -1,9 +1,11 @@
 import { describeAtRule, reportCssProblem } from "../../rules-api/index.js";
 import { defineRule } from "./define-rule.js";
+const CHECKS = ['malformed_custom_media', 'duplicate_breakpoint', 'unknown_breakpoint_name', 'changed_breakpoint_range', 'undeclared_breakpoint', 'unknown_breakpoint_range'];
 /** The converter's shape for a declaration's name: a dashed identifier. */
 const DASHED_NAME = /^--[A-Za-z0-9_-]+$/;
 export default defineRule({
     name: 'breakpoints',
+    checks: CHECKS,
     editors: ['studio2'],
     callbacks: {
         Program: ({ rulesApi, report }) => {
@@ -34,7 +36,7 @@ function isWellFormed(file, declaration, report) {
     if (hasShape(declaration))
         return true;
     const params = `${declaration.name} ${declaration.query}`.trim();
-    reportCssProblem(report, file.name, declaration.line, `\`@custom-media ${params}\` isn't \`--<name> <media query>\`; write it like \`@custom-media --mobile (max-width: 750px);\` (tracker CONV-astParser.ts:328).`);
+    reportCssProblem(report, file.name, declaration.line, 'malformed_custom_media', `\`@custom-media ${params}\` isn't \`--<name> <media query>\`; write it like \`@custom-media --mobile (max-width: 750px);\` (tracker CONV-astParser.ts:328).`);
     return false;
 }
 /** Reports a second `@custom-media` of a name the file already declares: the import can't tell two ranges with one name apart (CONV-breakpoints.ts:197). */
@@ -42,7 +44,7 @@ function isFirstOfName(file, declaration, first, report) {
     const earlier = first.get(declaration.name);
     if (!earlier)
         return first.set(declaration.name, declaration), true;
-    reportCssProblem(report, file.name, declaration.line, `\`@custom-media ${declaration.name}\` is declared again (first at ${file.name}:${earlier.line}). The import can't tell two ranges with one name apart: keep one (tracker CONV-breakpoints.ts:197).`);
+    reportCssProblem(report, file.name, declaration.line, 'duplicate_breakpoint', `\`@custom-media ${declaration.name}\` is declared again (first at ${file.name}:${earlier.line}). The import can't tell two ranges with one name apart: keep one (tracker CONV-breakpoints.ts:197).`);
     return false;
 }
 /** Reports a page file's declaration whose name isn't one of the site's (CONV-astParser.ts:335). */
@@ -50,7 +52,7 @@ function isSiteName(file, declaration, site, report) {
     const names = site.breakpoints.map(({ name }) => name);
     if (names.includes(declaration.name))
         return true;
-    reportCssProblem(report, file.name, declaration.line, `\`@custom-media ${declaration.name}\` isn't one of the site's named breakpoints (the theme has ${names.join(', ') || 'none'}). Use a range the site declares; breakpoints are added in the editor, not in CSS (tracker CONV-astParser.ts:335).`);
+    reportCssProblem(report, file.name, declaration.line, 'unknown_breakpoint_name', `\`@custom-media ${declaration.name}\` isn't one of the site's named breakpoints (the theme has ${names.join(', ') || 'none'}). Use a range the site declares; breakpoints are added in the editor, not in CSS (tracker CONV-astParser.ts:335).`);
     return false;
 }
 /** Reports a page file's declaration whose range isn't the site's for that name, to the letter: the import compares the text (CONV-astParser.ts:339). */
@@ -58,7 +60,7 @@ function keepsSiteRange(file, declaration, site, report) {
     const exported = getSiteRange(declaration.name, site);
     if (exported.trim() === declaration.query.trim())
         return true;
-    reportCssProblem(report, file.name, declaration.line, `\`@custom-media ${declaration.name} ${declaration.query}\` changes the site's range for ${declaration.name}, which is \`${exported}\`. Restore it; a breakpoint's width is changed in the editor, not in CSS (tracker CONV-astParser.ts:339).`);
+    reportCssProblem(report, file.name, declaration.line, 'changed_breakpoint_range', `\`@custom-media ${declaration.name} ${declaration.query}\` changes the site's range for ${declaration.name}, which is \`${exported}\`. Restore it; a breakpoint's width is changed in the editor, not in CSS (tracker CONV-astParser.ts:339).`);
     return false;
 }
 /** Reports a `@media (--name)` with no declaration of that name in the same file (CONV-breakpoints.ts:57). A malformed declaration of the name (its own line) counts as the declaration, so the use gets no second line. */
@@ -71,7 +73,7 @@ function checkNamedUses(file, site, report) {
         const fix = range
             ? `add \`@custom-media ${name} ${range};\` at the top of ${file.name}, or write the range itself, \`@media ${range}\``
             : `add \`@custom-media ${name} (<its range>);\` at the top of ${file.name} (the range the site gives it), or write the range itself`;
-        reportCssProblem(report, file.name, line, `\`@media (${name})\` uses a name the file doesn't declare: ${fix} (tracker CONV-breakpoints.ts:57).`);
+        reportCssProblem(report, file.name, line, 'undeclared_breakpoint', `\`@media (${name})\` uses a name the file doesn't declare: ${fix} (tracker CONV-breakpoints.ts:57).`);
     }
 }
 /** Reports each `@media` of a file whose range is none of the site's (P4-R01, CONV-breakpoints.ts:75); nothing without a theme to compare with. A name is read through the file's declaration when that declaration is the site's; otherwise the steps above report it. A component's own breakpoint (inside `@scope`) is compared once unmapped.json is read. */
@@ -84,7 +86,7 @@ function checkRanges(file, site, report) {
         const query = resolve(media, file.declared, site);
         if (query === null || site.breakpoints.some((breakpoint) => canonical(breakpoint.query) === canonical(query)))
             continue;
-        reportCssProblem(report, file.name, media.line, `\`${describeAtRule({ name: 'media', params: media.query })}\` is a breakpoint the site doesn't have. Write one of the theme's breakpoints: ${describe(site.breakpoints)} (rule P4-R01; tracker CONV-breakpoints.ts:75). The import refuses a value for a breakpoint the site doesn't have.`);
+        reportCssProblem(report, file.name, media.line, 'unknown_breakpoint_range', `\`${describeAtRule({ name: 'media', params: media.query })}\` is a breakpoint the site doesn't have. Write one of the theme's breakpoints: ${describe(site.breakpoints)} (rule P4-R01; tracker CONV-breakpoints.ts:75). The import refuses a value for a breakpoint the site doesn't have.`);
     }
 }
 // ── reading the files ──

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

@@ -1,9 +1,11 @@
 import { BREAKPOINT_AT_RULES, createCssFileReporter, describeAtRule, getCssChildren, ORIGAMI_TARGETS, PREAMBLE_LAYER } from "../../rules-api/index.js";
 import { defineRule } from "./define-rule.js";
+const CHECKS = ['css_import', 'unsupported_top_level_at_rule', 'top_level_declaration', 'invalid_scope_content', 'at_rule_in_breakpoint', 'declaration_in_breakpoint', 'missing_at_rule_block', 'invalid_layout_rule_content', 'invalid_target_content', 'unknown_target', 'duplicate_target', 'at_rule_in_style_rule'];
 /** The import's leading-import line (cssFileParser.ts `IMPORT_LINE_PATTERN`). */
 const IMPORT_LINE = /^@import '([^']+)';$/;
 export default defineRule({
     name: 'css-file-nesting',
+    checks: CHECKS,
     editors: ['studio2'],
     callbacks: {
         Program: ({ rulesApi, report }) => {
@@ -35,7 +37,7 @@ function checkTopLevel(root, file, report) {
 }
 function checkTopAtRule(node, file, isLeadingImport, reportInFile) {
     if (node.name === 'import' && isLeadingImport)
-        return reportInFile(node, `\`@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 (tracker CONV-fromBundle.ts:987).`);
     if (node.name === 'custom-media')
         return;
     if (node.name === 'mixin' && file !== 'layout.css')
@@ -46,19 +48,19 @@ function checkTopAtRule(node, file, isLeadingImport, reportInFile) {
         return;
     if (BREAKPOINT_AT_RULES.includes(node.name))
         return checkBreakpoint(node, file, reportInFile);
-    reportInFile(node, `\`@${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)} (tracker CONV-utils.ts:92).`);
 }
 /** 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, `\`${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 { … }\`) (tracker CONV-astParser.ts:412).`);
 }
 /** 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, `\`@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 (tracker CONV-astParser.ts:399).`);
     }
     if (hasBlock(scopeChildren[0], reportInFile))
         checkBreakpointContent(scopeChildren[0], 'layout.css', reportInFile);
@@ -81,7 +83,7 @@ function getScopedMedia(node, reportInFile) {
             continue;
         }
         if (!isMedia(first)) {
-            reportInFile(current, `\`@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 (tracker CONV-utils.ts:92).`);
             return null;
         }
         if (!hasBlock(first, reportInFile))
@@ -96,16 +98,16 @@ function checkBreakpointContent(media, file, reportInFile) {
         if (child.type === 'rule')
             checkRule(child, file, reportInFile);
         else if (child.type === 'atrule')
-            reportInFile(child, `\`@${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 (tracker CONV-astParser.ts:147).`);
         else if (child.type === 'decl')
-            reportInFile(child, `\`${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 { … } }\` (tracker CONV-astParser.ts:151).`);
     }
 }
 /** 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, `\`${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 (tracker CONV-utils.ts:76).`);
     return false;
 }
 /** An element rule: layout's (CONV-astParser.ts:74, :51, :54, :57) or style's and theme's (CONV-astParser.ts:95). */
@@ -127,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, `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} (tracker CONV-astParser.ts:74).`);
     }
 }
 /** 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, `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} (tracker CONV-astParser.ts:51).`);
     if (node.nodes === undefined)
         return reportTargetShape("Give it a block with the container's declarations");
     if (!ORIGAMI_TARGETS.includes(target))
-        return reportInFile(node, `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]}\` (tracker CONV-astParser.ts:54).`);
     if (seenTargets.has(target))
-        return reportInFile(node, `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 (tracker CONV-astParser.ts:57).`);
     seenTargets.add(target);
     const nested = getCssChildren(node).find((child) => child.type !== 'decl');
     if (!nested)
@@ -151,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, `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 (…) { &… { … } } }\`) (tracker CONV-astParser.ts:95).`);
         }
     }
 }