@gallop.software/canon 2.0.2 → 2.2.0

package/dist/eslint/configs/recommended.d.ts

@@ -8,6 +8,8 @@ declare const recommendedConfig: {
         'gallop/no-client-blocks': string;
         'gallop/no-container-in-section': string;
         'gallop/prefer-component-props': string;
+        'gallop/prefer-layout-components': string;
+        'gallop/background-image-rounded': string;
     };
 };
 export default recommendedConfig;

package/dist/eslint/configs/recommended.js

@@ -9,7 +9,9 @@ const recommendedConfig = {
         'gallop/no-client-blocks': 'warn',
         'gallop/no-container-in-section': 'warn',
         'gallop/prefer-component-props': 'warn',
+        'gallop/prefer-layout-components': 'warn',
+        'gallop/background-image-rounded': 'warn',
     },
 };
 export default recommendedConfig;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVjb21tZW5kZWQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZXNsaW50L2NvbmZpZ3MvcmVjb21tZW5kZWQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7OztHQUdHO0FBQ0gsTUFBTSxpQkFBaUIsR0FBRztJQUN4QixPQUFPLEVBQUUsQ0FBQyxRQUFRLENBQUM7SUFDbkIsS0FBSyxFQUFFO1FBQ0wsMENBQTBDO1FBQzFDLHlCQUF5QixFQUFFLE1BQU07UUFDakMsZ0NBQWdDLEVBQUUsTUFBTTtRQUN4QywrQkFBK0IsRUFBRSxNQUFNO0tBQ3hDO0NBQ0YsQ0FBQTtBQUVELGVBQWUsaUJBQWlCLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFJlY29tbWVuZGVkIGNvbmZpZ3VyYXRpb25cbiAqIEEgc2Vuc2libGUgZGVmYXVsdCBmb3IgYW55IEdhbGxvcC1iYXNlZCB0ZW1wbGF0ZVxuICovXG5jb25zdCByZWNvbW1lbmRlZENvbmZpZyA9IHtcbiAgcGx1Z2luczogWydnYWxsb3AnXSxcbiAgcnVsZXM6IHtcbiAgICAvLyBDb3JlIHJ1bGVzIHRoYXQgYXBwbHkgdG8gbW9zdCB0ZW1wbGF0ZXNcbiAgICAnZ2FsbG9wL25vLWNsaWVudC1ibG9ja3MnOiAnd2FybicsXG4gICAgJ2dhbGxvcC9uby1jb250YWluZXItaW4tc2VjdGlvbic6ICd3YXJuJyxcbiAgICAnZ2FsbG9wL3ByZWZlci1jb21wb25lbnQtcHJvcHMnOiAnd2FybicsXG4gIH0sXG59XG5cbmV4cG9ydCBkZWZhdWx0IHJlY29tbWVuZGVkQ29uZmlnXG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVjb21tZW5kZWQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZXNsaW50L2NvbmZpZ3MvcmVjb21tZW5kZWQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7OztHQUdHO0FBQ0gsTUFBTSxpQkFBaUIsR0FBRztJQUN4QixPQUFPLEVBQUUsQ0FBQyxRQUFRLENBQUM7SUFDbkIsS0FBSyxFQUFFO1FBQ0wsMENBQTBDO1FBQzFDLHlCQUF5QixFQUFFLE1BQU07UUFDakMsZ0NBQWdDLEVBQUUsTUFBTTtRQUN4QywrQkFBK0IsRUFBRSxNQUFNO1FBQ3ZDLGlDQUFpQyxFQUFFLE1BQU07UUFDekMsaUNBQWlDLEVBQUUsTUFBTTtLQUMxQztDQUNGLENBQUE7QUFFRCxlQUFlLGlCQUFpQixDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBSZWNvbW1lbmRlZCBjb25maWd1cmF0aW9uXG4gKiBBIHNlbnNpYmxlIGRlZmF1bHQgZm9yIGFueSBHYWxsb3AtYmFzZWQgdGVtcGxhdGVcbiAqL1xuY29uc3QgcmVjb21tZW5kZWRDb25maWcgPSB7XG4gIHBsdWdpbnM6IFsnZ2FsbG9wJ10sXG4gIHJ1bGVzOiB7XG4gICAgLy8gQ29yZSBydWxlcyB0aGF0IGFwcGx5IHRvIG1vc3QgdGVtcGxhdGVzXG4gICAgJ2dhbGxvcC9uby1jbGllbnQtYmxvY2tzJzogJ3dhcm4nLFxuICAgICdnYWxsb3Avbm8tY29udGFpbmVyLWluLXNlY3Rpb24nOiAnd2FybicsXG4gICAgJ2dhbGxvcC9wcmVmZXItY29tcG9uZW50LXByb3BzJzogJ3dhcm4nLFxuICAgICdnYWxsb3AvcHJlZmVyLWxheW91dC1jb21wb25lbnRzJzogJ3dhcm4nLFxuICAgICdnYWxsb3AvYmFja2dyb3VuZC1pbWFnZS1yb3VuZGVkJzogJ3dhcm4nLFxuICB9LFxufVxuXG5leHBvcnQgZGVmYXVsdCByZWNvbW1lbmRlZENvbmZpZ1xuIl19

package/dist/eslint/configs/speedwell.d.ts

@@ -8,6 +8,8 @@ declare const speedwellConfig: {
         'gallop/no-client-blocks': string;
         'gallop/no-container-in-section': string;
         'gallop/prefer-component-props': string;
+        'gallop/prefer-layout-components': string;
+        'gallop/background-image-rounded': string;
     };
 };
 export default speedwellConfig;

package/dist/eslint/configs/speedwell.js

@@ -11,7 +11,11 @@ const speedwellConfig = {
         'gallop/no-container-in-section': 'warn',
         // Use component props instead of className for style values
         'gallop/prefer-component-props': 'warn',
+        // Use Grid/Columns instead of raw div with grid classes
+        'gallop/prefer-layout-components': 'warn',
+        // Background images must have rounded="rounded-none"
+        'gallop/background-image-rounded': 'warn',
     },
 };
 export default speedwellConfig;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3BlZWR3ZWxsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2VzbGludC9jb25maWdzL3NwZWVkd2VsbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFDSCxNQUFNLGVBQWUsR0FBRztJQUN0QixPQUFPLEVBQUUsQ0FBQyxRQUFRLENBQUM7SUFDbkIsS0FBSyxFQUFFO1FBQ0wsMEVBQTBFO1FBQzFFLHlCQUF5QixFQUFFLE1BQU07UUFFakMsdUNBQXVDO1FBQ3ZDLGdDQUFnQyxFQUFFLE1BQU07UUFFeEMsNERBQTREO1FBQzVELCtCQUErQixFQUFFLE1BQU07S0FDeEM7Q0FDRixDQUFBO0FBRUQsZUFBZSxlQUFlLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFNwZWVkd2VsbCB0ZW1wbGF0ZSBjb25maWd1cmF0aW9uXG4gKiBFbmFibGVzIGFsbCBHYWxsb3AgcnVsZXMgcmVsZXZhbnQgdG8gdGhlIFNwZWVkd2VsbCBhcmNoaXRlY3R1cmVcbiAqL1xuY29uc3Qgc3BlZWR3ZWxsQ29uZmlnID0ge1xuICBwbHVnaW5zOiBbJ2dhbGxvcCddLFxuICBydWxlczoge1xuICAgIC8vIEJsb2NrcyBzaG91bGQgYmUgc2VydmVyIGNvbXBvbmVudHMgLSBleHRyYWN0IGNsaWVudCBsb2dpYyB0byBjb21wb25lbnRzXG4gICAgJ2dhbGxvcC9uby1jbGllbnQtYmxvY2tzJzogJ3dhcm4nLFxuXG4gICAgLy8gU2VjdGlvbiBhbHJlYWR5IHByb3ZpZGVzIGNvbnRhaW5tZW50XG4gICAgJ2dhbGxvcC9uby1jb250YWluZXItaW4tc2VjdGlvbic6ICd3YXJuJyxcblxuICAgIC8vIFVzZSBjb21wb25lbnQgcHJvcHMgaW5zdGVhZCBvZiBjbGFzc05hbWUgZm9yIHN0eWxlIHZhbHVlc1xuICAgICdnYWxsb3AvcHJlZmVyLWNvbXBvbmVudC1wcm9wcyc6ICd3YXJuJyxcbiAgfSxcbn1cblxuZXhwb3J0IGRlZmF1bHQgc3BlZWR3ZWxsQ29uZmlnXG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3BlZWR3ZWxsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2VzbGludC9jb25maWdzL3NwZWVkd2VsbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFDSCxNQUFNLGVBQWUsR0FBRztJQUN0QixPQUFPLEVBQUUsQ0FBQyxRQUFRLENBQUM7SUFDbkIsS0FBSyxFQUFFO1FBQ0wsMEVBQTBFO1FBQzFFLHlCQUF5QixFQUFFLE1BQU07UUFFakMsdUNBQXVDO1FBQ3ZDLGdDQUFnQyxFQUFFLE1BQU07UUFFeEMsNERBQTREO1FBQzVELCtCQUErQixFQUFFLE1BQU07UUFFdkMsd0RBQXdEO1FBQ3hELGlDQUFpQyxFQUFFLE1BQU07UUFFekMscURBQXFEO1FBQ3JELGlDQUFpQyxFQUFFLE1BQU07S0FDMUM7Q0FDRixDQUFBO0FBRUQsZUFBZSxlQUFlLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFNwZWVkd2VsbCB0ZW1wbGF0ZSBjb25maWd1cmF0aW9uXG4gKiBFbmFibGVzIGFsbCBHYWxsb3AgcnVsZXMgcmVsZXZhbnQgdG8gdGhlIFNwZWVkd2VsbCBhcmNoaXRlY3R1cmVcbiAqL1xuY29uc3Qgc3BlZWR3ZWxsQ29uZmlnID0ge1xuICBwbHVnaW5zOiBbJ2dhbGxvcCddLFxuICBydWxlczoge1xuICAgIC8vIEJsb2NrcyBzaG91bGQgYmUgc2VydmVyIGNvbXBvbmVudHMgLSBleHRyYWN0IGNsaWVudCBsb2dpYyB0byBjb21wb25lbnRzXG4gICAgJ2dhbGxvcC9uby1jbGllbnQtYmxvY2tzJzogJ3dhcm4nLFxuXG4gICAgLy8gU2VjdGlvbiBhbHJlYWR5IHByb3ZpZGVzIGNvbnRhaW5tZW50XG4gICAgJ2dhbGxvcC9uby1jb250YWluZXItaW4tc2VjdGlvbic6ICd3YXJuJyxcblxuICAgIC8vIFVzZSBjb21wb25lbnQgcHJvcHMgaW5zdGVhZCBvZiBjbGFzc05hbWUgZm9yIHN0eWxlIHZhbHVlc1xuICAgICdnYWxsb3AvcHJlZmVyLWNvbXBvbmVudC1wcm9wcyc6ICd3YXJuJyxcblxuICAgIC8vIFVzZSBHcmlkL0NvbHVtbnMgaW5zdGVhZCBvZiByYXcgZGl2IHdpdGggZ3JpZCBjbGFzc2VzXG4gICAgJ2dhbGxvcC9wcmVmZXItbGF5b3V0LWNvbXBvbmVudHMnOiAnd2FybicsXG5cbiAgICAvLyBCYWNrZ3JvdW5kIGltYWdlcyBtdXN0IGhhdmUgcm91bmRlZD1cInJvdW5kZWQtbm9uZVwiXG4gICAgJ2dhbGxvcC9iYWNrZ3JvdW5kLWltYWdlLXJvdW5kZWQnOiAnd2FybicsXG4gIH0sXG59XG5cbmV4cG9ydCBkZWZhdWx0IHNwZWVkd2VsbENvbmZpZ1xuIl19

package/dist/eslint/index.d.ts

@@ -14,6 +14,8 @@ declare const plugin: {
             name: string;
         };
         'prefer-typography-components': import("eslint").Rule.RuleModule;
+        'prefer-layout-components': import("eslint").Rule.RuleModule;
+        'background-image-rounded': import("eslint").Rule.RuleModule;
     };
     configs: {
         speedwell: {
@@ -22,6 +24,8 @@ declare const plugin: {
                 'gallop/no-client-blocks': string;
                 'gallop/no-container-in-section': string;
                 'gallop/prefer-component-props': string;
+                'gallop/prefer-layout-components': string;
+                'gallop/background-image-rounded': string;
             };
         };
         recommended: {
@@ -30,6 +34,8 @@ declare const plugin: {
                 'gallop/no-client-blocks': string;
                 'gallop/no-container-in-section': string;
                 'gallop/prefer-component-props': string;
+                'gallop/prefer-layout-components': string;
+                'gallop/background-image-rounded': string;
             };
         };
     };

package/dist/eslint/index.js

@@ -2,6 +2,8 @@ import noClientBlocks from './rules/no-client-blocks.js';
 import noContainerInSection from './rules/no-container-in-section.js';
 import preferComponentProps from './rules/prefer-component-props.js';
 import preferTypographyComponents from './rules/prefer-typography-components.js';
+import preferLayoutComponents from './rules/prefer-layout-components.js';
+import backgroundImageRounded from './rules/background-image-rounded.js';
 import speedwellConfig from './configs/speedwell.js';
 import recommendedConfig from './configs/recommended.js';
 const plugin = {
@@ -14,6 +16,8 @@ const plugin = {
         'no-container-in-section': noContainerInSection,
         'prefer-component-props': preferComponentProps,
         'prefer-typography-components': preferTypographyComponents,
+        'prefer-layout-components': preferLayoutComponents,
+        'background-image-rounded': backgroundImageRounded,
     },
     configs: {
         speedwell: speedwellConfig,
@@ -21,4 +25,4 @@ const plugin = {
     },
 };
 export default plugin;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZXNsaW50L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sY0FBYyxNQUFNLDZCQUE2QixDQUFBO0FBQ3hELE9BQU8sb0JBQW9CLE1BQU0sb0NBQW9DLENBQUE7QUFDckUsT0FBTyxvQkFBb0IsTUFBTSxtQ0FBbUMsQ0FBQTtBQUNwRSxPQUFPLDBCQUEwQixNQUFNLHlDQUF5QyxDQUFBO0FBQ2hGLE9BQU8sZUFBZSxNQUFNLHdCQUF3QixDQUFBO0FBQ3BELE9BQU8saUJBQWlCLE1BQU0sMEJBQTBCLENBQUE7QUFFeEQsTUFBTSxNQUFNLEdBQUc7SUFDYixJQUFJLEVBQUU7UUFDSixJQUFJLEVBQUUsc0JBQXNCO1FBQzVCLE9BQU8sRUFBRSxPQUFPO0tBQ2pCO0lBQ0QsS0FBSyxFQUFFO1FBQ0wsa0JBQWtCLEVBQUUsY0FBYztRQUNsQyx5QkFBeUIsRUFBRSxvQkFBb0I7UUFDL0Msd0JBQXdCLEVBQUUsb0JBQW9CO1FBQzlDLDhCQUE4QixFQUFFLDBCQUEwQjtLQUMzRDtJQUNELE9BQU8sRUFBRTtRQUNQLFNBQVMsRUFBRSxlQUFlO1FBQzFCLFdBQVcsRUFBRSxpQkFBaUI7S0FDL0I7Q0FDRixDQUFBO0FBRUQsZUFBZSxNQUFNLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgbm9DbGllbnRCbG9ja3MgZnJvbSAnLi9ydWxlcy9uby1jbGllbnQtYmxvY2tzLmpzJ1xuaW1wb3J0IG5vQ29udGFpbmVySW5TZWN0aW9uIGZyb20gJy4vcnVsZXMvbm8tY29udGFpbmVyLWluLXNlY3Rpb24uanMnXG5pbXBvcnQgcHJlZmVyQ29tcG9uZW50UHJvcHMgZnJvbSAnLi9ydWxlcy9wcmVmZXItY29tcG9uZW50LXByb3BzLmpzJ1xuaW1wb3J0IHByZWZlclR5cG9ncmFwaHlDb21wb25lbnRzIGZyb20gJy4vcnVsZXMvcHJlZmVyLXR5cG9ncmFwaHktY29tcG9uZW50cy5qcydcbmltcG9ydCBzcGVlZHdlbGxDb25maWcgZnJvbSAnLi9jb25maWdzL3NwZWVkd2VsbC5qcydcbmltcG9ydCByZWNvbW1lbmRlZENvbmZpZyBmcm9tICcuL2NvbmZpZ3MvcmVjb21tZW5kZWQuanMnXG5cbmNvbnN0IHBsdWdpbiA9IHtcbiAgbWV0YToge1xuICAgIG5hbWU6ICdlc2xpbnQtcGx1Z2luLWdhbGxvcCcsXG4gICAgdmVyc2lvbjogJzEuMC4xJyxcbiAgfSxcbiAgcnVsZXM6IHtcbiAgICAnbm8tY2xpZW50LWJsb2Nrcyc6IG5vQ2xpZW50QmxvY2tzLFxuICAgICduby1jb250YWluZXItaW4tc2VjdGlvbic6IG5vQ29udGFpbmVySW5TZWN0aW9uLFxuICAgICdwcmVmZXItY29tcG9uZW50LXByb3BzJzogcHJlZmVyQ29tcG9uZW50UHJvcHMsXG4gICAgJ3ByZWZlci10eXBvZ3JhcGh5LWNvbXBvbmVudHMnOiBwcmVmZXJUeXBvZ3JhcGh5Q29tcG9uZW50cyxcbiAgfSxcbiAgY29uZmlnczoge1xuICAgIHNwZWVkd2VsbDogc3BlZWR3ZWxsQ29uZmlnLFxuICAgIHJlY29tbWVuZGVkOiByZWNvbW1lbmRlZENvbmZpZyxcbiAgfSxcbn1cblxuZXhwb3J0IGRlZmF1bHQgcGx1Z2luXG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/dist/eslint/rules/background-image-rounded.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+declare const rule: Rule.RuleModule;
+export default rule;

package/dist/eslint/rules/background-image-rounded.js

@@ -0,0 +1,122 @@
+import { getCanonUrl, getCanonPattern } from '../utils/canon.js';
+const RULE_NAME = 'background-image-rounded';
+const pattern = getCanonPattern(RULE_NAME);
+const rule = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: pattern?.summary || 'Background images must have rounded="rounded-none"',
+            recommended: true,
+            url: getCanonUrl(RULE_NAME),
+        },
+        messages: {
+            requireRoundedNone: `[Canon ${pattern?.id || '019'}] Background Image components (with absolute inset-0) must have rounded="rounded-none" to prevent corner clipping.`,
+        },
+        schema: [],
+    },
+    create(context) {
+        const filename = context.filename || context.getFilename();
+        // Only apply to block files
+        if (!filename.includes('/blocks/')) {
+            return {};
+        }
+        return {
+            JSXOpeningElement(node) {
+                const elementName = node.name?.name;
+                // Only check Image components
+                if (elementName !== 'Image') {
+                    return;
+                }
+                // Check if className contains 'absolute' and 'inset-0'
+                const classNameAttr = node.attributes?.find((attr) => attr.type === 'JSXAttribute' &&
+                    attr.name?.name === 'className');
+                if (!classNameAttr) {
+                    return;
+                }
+                const classValue = getClassNameValue(classNameAttr);
+                if (!classValue) {
+                    return;
+                }
+                // Check if this is a background image pattern
+                if (!isBackgroundImage(classValue)) {
+                    return;
+                }
+                // Check if rounded="rounded-none" is set
+                const roundedAttr = node.attributes?.find((attr) => attr.type === 'JSXAttribute' &&
+                    attr.name?.name === 'rounded');
+                if (!roundedAttr) {
+                    context.report({
+                        node,
+                        messageId: 'requireRoundedNone',
+                    });
+                    return;
+                }
+                // Check the value of rounded prop
+                const roundedValue = getRoundedValue(roundedAttr);
+                if (roundedValue !== 'rounded-none') {
+                    context.report({
+                        node,
+                        messageId: 'requireRoundedNone',
+                    });
+                }
+            },
+        };
+    },
+};
+/**
+ * Extract className value from attribute
+ */
+function getClassNameValue(attr) {
+    // Handle string literal
+    if (attr.value?.type === 'Literal' && typeof attr.value.value === 'string') {
+        return attr.value.value;
+    }
+    // Handle JSX expression container with template literal
+    if (attr.value?.type === 'JSXExpressionContainer') {
+        const expr = attr.value.expression;
+        if (expr.type === 'TemplateLiteral') {
+            // Combine all quasis
+            return expr.quasis?.map((q) => q.value?.raw || '').join(' ') || null;
+        }
+        // Handle clsx or other function calls - extract string arguments
+        if (expr.type === 'CallExpression') {
+            const strings = [];
+            for (const arg of expr.arguments || []) {
+                if (arg.type === 'Literal' && typeof arg.value === 'string') {
+                    strings.push(arg.value);
+                }
+                if (arg.type === 'TemplateLiteral') {
+                    strings.push(arg.quasis?.map((q) => q.value?.raw || '').join(' ') || '');
+                }
+            }
+            return strings.join(' ');
+        }
+    }
+    return null;
+}
+/**
+ * Check if className indicates a background image pattern
+ */
+function isBackgroundImage(classValue) {
+    const classes = classValue.split(/\s+/);
+    const hasAbsolute = classes.includes('absolute');
+    const hasInset0 = classes.includes('inset-0');
+    return hasAbsolute && hasInset0;
+}
+/**
+ * Extract rounded prop value
+ */
+function getRoundedValue(attr) {
+    if (attr.value?.type === 'Literal' && typeof attr.value.value === 'string') {
+        return attr.value.value;
+    }
+    if (attr.value?.type === 'JSXExpressionContainer') {
+        const expr = attr.value.expression;
+        if (expr.type === 'Literal' && typeof expr.value === 'string') {
+            return expr.value;
+        }
+    }
+    return null;
+}
+export default rule;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"background-image-rounded.js","sourceRoot":"","sources":["../../../src/eslint/rules/background-image-rounded.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAEhE,MAAM,SAAS,GAAG,0BAA0B,CAAA;AAC5C,MAAM,OAAO,GAAG,eAAe,CAAC,SAAS,CAAC,CAAA;AAE1C,MAAM,IAAI,GAAoB;IAC5B,IAAI,EAAE;QACJ,IAAI,EAAE,YAAY;QAClB,IAAI,EAAE;YACJ,WAAW,EAAE,OAAO,EAAE,OAAO,IAAI,oDAAoD;YACrF,WAAW,EAAE,IAAI;YACjB,GAAG,EAAE,WAAW,CAAC,SAAS,CAAC;SAC5B;QACD,QAAQ,EAAE;YACR,kBAAkB,EAAE,UAAU,OAAO,EAAE,EAAE,IAAI,KAAK,oHAAoH;SACvK;QACD,MAAM,EAAE,EAAE;KACX;IAED,MAAM,CAAC,OAAO;QACZ,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAQ,IAAI,OAAO,CAAC,WAAW,EAAE,CAAA;QAE1D,4BAA4B;QAC5B,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC;YACnC,OAAO,EAAE,CAAA;QACX,CAAC;QAED,OAAO;YACL,iBAAiB,CAAC,IAAS;gBACzB,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,EAAE,IAAI,CAAA;gBAEnC,8BAA8B;gBAC9B,IAAI,WAAW,KAAK,OAAO,EAAE,CAAC;oBAC5B,OAAM;gBACR,CAAC;gBAED,uDAAuD;gBACvD,MAAM,aAAa,GAAG,IAAI,CAAC,UAAU,EAAE,IAAI,CACzC,CAAC,IAAS,EAAE,EAAE,CACZ,IAAI,CAAC,IAAI,KAAK,cAAc;oBAC5B,IAAI,CAAC,IAAI,EAAE,IAAI,KAAK,WAAW,CAClC,CAAA;gBAED,IAAI,CAAC,aAAa,EAAE,CAAC;oBACnB,OAAM;gBACR,CAAC;gBAED,MAAM,UAAU,GAAG,iBAAiB,CAAC,aAAa,CAAC,CAAA;gBACnD,IAAI,CAAC,UAAU,EAAE,CAAC;oBAChB,OAAM;gBACR,CAAC;gBAED,8CAA8C;gBAC9C,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC,EAAE,CAAC;oBACnC,OAAM;gBACR,CAAC;gBAED,yCAAyC;gBACzC,MAAM,WAAW,GAAG,IAAI,CAAC,UAAU,EAAE,IAAI,CACvC,CAAC,IAAS,EAAE,EAAE,CACZ,IAAI,CAAC,IAAI,KAAK,cAAc;oBAC5B,IAAI,CAAC,IAAI,EAAE,IAAI,KAAK,SAAS,CAChC,CAAA;gBAED,IAAI,CAAC,WAAW,EAAE,CAAC;oBACjB,OAAO,CAAC,MAAM,CAAC;wBACb,IAAI;wBACJ,SAAS,EAAE,oBAAoB;qBAChC,CAAC,CAAA;oBACF,OAAM;gBACR,CAAC;gBAED,kCAAkC;gBAClC,MAAM,YAAY,GAAG,eAAe,CAAC,WAAW,CAAC,CAAA;gBACjD,IAAI,YAAY,KAAK,cAAc,EAAE,CAAC;oBACpC,OAAO,CAAC,MAAM,CAAC;wBACb,IAAI;wBACJ,SAAS,EAAE,oBAAoB;qBAChC,CAAC,CAAA;gBACJ,CAAC;YACH,CAAC;SACF,CAAA;IACH,CAAC;CACF,CAAA;AAED;;GAEG;AACH,SAAS,iBAAiB,CAAC,IAAS;IAClC,wBAAwB;IACxB,IAAI,IAAI,CAAC,KAAK,EAAE,IAAI,KAAK,SAAS,IAAI,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC3E,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,CAAA;IACzB,CAAC;IAED,wDAAwD;IACxD,IAAI,IAAI,CAAC,KAAK,EAAE,IAAI,KAAK,wBAAwB,EAAE,CAAC;QAClD,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,CAAA;QAElC,IAAI,IAAI,CAAC,IAAI,KAAK,iBAAiB,EAAE,CAAC;YACpC,qBAAqB;YACrB,OAAO,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,EAAE,GAAG,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,IAAI,CAAA;QAC3E,CAAC;QAED,iEAAiE;QACjE,IAAI,IAAI,CAAC,IAAI,KAAK,gBAAgB,EAAE,CAAC;YACnC,MAAM,OAAO,GAAa,EAAE,CAAA;YAC5B,KAAK,MAAM,GAAG,IAAI,IAAI,CAAC,SAAS,IAAI,EAAE,EAAE,CAAC;gBACvC,IAAI,GAAG,CAAC,IAAI,KAAK,SAAS,IAAI,OAAO,GAAG,CAAC,KAAK,KAAK,QAAQ,EAAE,CAAC;oBAC5D,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAA;gBACzB,CAAC;gBACD,IAAI,GAAG,CAAC,IAAI,KAAK,iBAAiB,EAAE,CAAC;oBACnC,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,EAAE,GAAG,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,CAAA;gBAC/E,CAAC;YACH,CAAC;YACD,OAAO,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;QAC1B,CAAC;IACH,CAAC;IAED,OAAO,IAAI,CAAA;AACb,CAAC;AAED;;GAEG;AACH,SAAS,iBAAiB,CAAC,UAAkB;IAC3C,MAAM,OAAO,GAAG,UAAU,CAAC,KAAK,CAAC,KAAK,CAAC,CAAA;IACvC,MAAM,WAAW,GAAG,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAA;IAChD,MAAM,SAAS,GAAG,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAA;IAE7C,OAAO,WAAW,IAAI,SAAS,CAAA;AACjC,CAAC;AAED;;GAEG;AACH,SAAS,eAAe,CAAC,IAAS;IAChC,IAAI,IAAI,CAAC,KAAK,EAAE,IAAI,KAAK,SAAS,IAAI,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC3E,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,CAAA;IACzB,CAAC;IAED,IAAI,IAAI,CAAC,KAAK,EAAE,IAAI,KAAK,wBAAwB,EAAE,CAAC;QAClD,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,CAAA;QAClC,IAAI,IAAI,CAAC,IAAI,KAAK,SAAS,IAAI,OAAO,IAAI,CAAC,KAAK,KAAK,QAAQ,EAAE,CAAC;YAC9D,OAAO,IAAI,CAAC,KAAK,CAAA;QACnB,CAAC;IACH,CAAC;IAED,OAAO,IAAI,CAAA;AACb,CAAC;AAED,eAAe,IAAI,CAAA","sourcesContent":["import type { Rule } from 'eslint'\nimport { getCanonUrl, getCanonPattern } from '../utils/canon.js'\n\nconst RULE_NAME = 'background-image-rounded'\nconst pattern = getCanonPattern(RULE_NAME)\n\nconst rule: Rule.RuleModule = {\n  meta: {\n    type: 'suggestion',\n    docs: {\n      description: pattern?.summary || 'Background images must have rounded=\"rounded-none\"',\n      recommended: true,\n      url: getCanonUrl(RULE_NAME),\n    },\n    messages: {\n      requireRoundedNone: `[Canon ${pattern?.id || '019'}] Background Image components (with absolute inset-0) must have rounded=\"rounded-none\" to prevent corner clipping.`,\n    },\n    schema: [],\n  },\n\n  create(context) {\n    const filename = context.filename || context.getFilename()\n\n    // Only apply to block files\n    if (!filename.includes('/blocks/')) {\n      return {}\n    }\n\n    return {\n      JSXOpeningElement(node: any) {\n        const elementName = node.name?.name\n\n        // Only check Image components\n        if (elementName !== 'Image') {\n          return\n        }\n\n        // Check if className contains 'absolute' and 'inset-0'\n        const classNameAttr = node.attributes?.find(\n          (attr: any) =>\n            attr.type === 'JSXAttribute' &&\n            attr.name?.name === 'className'\n        )\n\n        if (!classNameAttr) {\n          return\n        }\n\n        const classValue = getClassNameValue(classNameAttr)\n        if (!classValue) {\n          return\n        }\n\n        // Check if this is a background image pattern\n        if (!isBackgroundImage(classValue)) {\n          return\n        }\n\n        // Check if rounded=\"rounded-none\" is set\n        const roundedAttr = node.attributes?.find(\n          (attr: any) =>\n            attr.type === 'JSXAttribute' &&\n            attr.name?.name === 'rounded'\n        )\n\n        if (!roundedAttr) {\n          context.report({\n            node,\n            messageId: 'requireRoundedNone',\n          })\n          return\n        }\n\n        // Check the value of rounded prop\n        const roundedValue = getRoundedValue(roundedAttr)\n        if (roundedValue !== 'rounded-none') {\n          context.report({\n            node,\n            messageId: 'requireRoundedNone',\n          })\n        }\n      },\n    }\n  },\n}\n\n/**\n * Extract className value from attribute\n */\nfunction getClassNameValue(attr: any): string | null {\n  // Handle string literal\n  if (attr.value?.type === 'Literal' && typeof attr.value.value === 'string') {\n    return attr.value.value\n  }\n\n  // Handle JSX expression container with template literal\n  if (attr.value?.type === 'JSXExpressionContainer') {\n    const expr = attr.value.expression\n\n    if (expr.type === 'TemplateLiteral') {\n      // Combine all quasis\n      return expr.quasis?.map((q: any) => q.value?.raw || '').join(' ') || null\n    }\n\n    // Handle clsx or other function calls - extract string arguments\n    if (expr.type === 'CallExpression') {\n      const strings: string[] = []\n      for (const arg of expr.arguments || []) {\n        if (arg.type === 'Literal' && typeof arg.value === 'string') {\n          strings.push(arg.value)\n        }\n        if (arg.type === 'TemplateLiteral') {\n          strings.push(arg.quasis?.map((q: any) => q.value?.raw || '').join(' ') || '')\n        }\n      }\n      return strings.join(' ')\n    }\n  }\n\n  return null\n}\n\n/**\n * Check if className indicates a background image pattern\n */\nfunction isBackgroundImage(classValue: string): boolean {\n  const classes = classValue.split(/\\s+/)\n  const hasAbsolute = classes.includes('absolute')\n  const hasInset0 = classes.includes('inset-0')\n  \n  return hasAbsolute && hasInset0\n}\n\n/**\n * Extract rounded prop value\n */\nfunction getRoundedValue(attr: any): string | null {\n  if (attr.value?.type === 'Literal' && typeof attr.value.value === 'string') {\n    return attr.value.value\n  }\n\n  if (attr.value?.type === 'JSXExpressionContainer') {\n    const expr = attr.value.expression\n    if (expr.type === 'Literal' && typeof expr.value === 'string') {\n      return expr.value\n    }\n  }\n\n  return null\n}\n\nexport default rule\n"]}

package/dist/eslint/rules/prefer-layout-components.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+declare const rule: Rule.RuleModule;
+export default rule;

package/dist/eslint/rules/prefer-layout-components.js

@@ -0,0 +1,113 @@
+import { getCanonUrl, getCanonPattern } from '../utils/canon.js';
+const RULE_NAME = 'prefer-layout-components';
+const pattern = getCanonPattern(RULE_NAME);
+const rule = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: pattern?.summary || 'Use Grid/Columns, not raw div with grid',
+            recommended: true,
+            url: getCanonUrl(RULE_NAME),
+        },
+        messages: {
+            useLayoutComponent: `[Canon ${pattern?.id || '018'}] Use the Grid or Columns component instead of <div className="grid ...">. Import: import { Grid, Columns, Column } from "@/components"`,
+        },
+        schema: [],
+    },
+    create(context) {
+        const filename = context.filename || context.getFilename();
+        // Only apply to block files
+        if (!filename.includes('/blocks/')) {
+            return {};
+        }
+        return {
+            JSXOpeningElement(node) {
+                const elementName = node.name?.name;
+                // Only check div elements
+                if (elementName !== 'div') {
+                    return;
+                }
+                // Check if className contains 'grid'
+                const classNameAttr = node.attributes?.find((attr) => attr.type === 'JSXAttribute' &&
+                    attr.name?.name === 'className');
+                if (!classNameAttr) {
+                    return;
+                }
+                // Handle string literal className
+                if (classNameAttr.value?.type === 'Literal') {
+                    const classValue = classNameAttr.value.value;
+                    if (typeof classValue === 'string' && hasGridClass(classValue)) {
+                        context.report({
+                            node,
+                            messageId: 'useLayoutComponent',
+                        });
+                    }
+                    return;
+                }
+                // Handle template literal className
+                if (classNameAttr.value?.type === 'JSXExpressionContainer') {
+                    const expr = classNameAttr.value.expression;
+                    // Direct template literal: className={`grid ...`}
+                    if (expr.type === 'TemplateLiteral') {
+                        const quasis = expr.quasis || [];
+                        for (const quasi of quasis) {
+                            if (quasi.value?.raw && hasGridClass(quasi.value.raw)) {
+                                context.report({
+                                    node,
+                                    messageId: 'useLayoutComponent',
+                                });
+                                return;
+                            }
+                        }
+                    }
+                    // clsx call: className={clsx('grid', ...)}
+                    if (expr.type === 'CallExpression') {
+                        const args = expr.arguments || [];
+                        for (const arg of args) {
+                            if (arg.type === 'Literal' && typeof arg.value === 'string') {
+                                if (hasGridClass(arg.value)) {
+                                    context.report({
+                                        node,
+                                        messageId: 'useLayoutComponent',
+                                    });
+                                    return;
+                                }
+                            }
+                            // Check template literals in clsx args
+                            if (arg.type === 'TemplateLiteral') {
+                                const quasis = arg.quasis || [];
+                                for (const quasi of quasis) {
+                                    if (quasi.value?.raw && hasGridClass(quasi.value.raw)) {
+                                        context.report({
+                                            node,
+                                            messageId: 'useLayoutComponent',
+                                        });
+                                        return;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            },
+        };
+    },
+};
+/**
+ * Check if a className string contains grid classes
+ * Matches: 'grid', 'grid-cols-', etc.
+ * Does NOT match: 'grid-area', component names with 'grid' in them
+ */
+function hasGridClass(classString) {
+    // Split by whitespace and check each class
+    const classes = classString.split(/\s+/);
+    for (const cls of classes) {
+        // Match standalone 'grid' or 'grid-cols-*' patterns
+        if (cls === 'grid' || cls.startsWith('grid-cols-')) {
+            return true;
+        }
+    }
+    return false;
+}
+export default rule;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"prefer-layout-components.js","sourceRoot":"","sources":["../../../src/eslint/rules/prefer-layout-components.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from 'eslint'\nimport { getCanonUrl, getCanonPattern } from '../utils/canon.js'\n\nconst RULE_NAME = 'prefer-layout-components'\nconst pattern = getCanonPattern(RULE_NAME)\n\nconst rule: Rule.RuleModule = {\n  meta: {\n    type: 'suggestion',\n    docs: {\n      description: pattern?.summary || 'Use Grid/Columns, not raw div with grid',\n      recommended: true,\n      url: getCanonUrl(RULE_NAME),\n    },\n    messages: {\n      useLayoutComponent: `[Canon ${pattern?.id || '018'}] Use the Grid or Columns component instead of <div className=\"grid ...\">. Import: import { Grid, Columns, Column } from \"@/components\"`,\n    },\n    schema: [],\n  },\n\n  create(context) {\n    const filename = context.filename || context.getFilename()\n\n    // Only apply to block files\n    if (!filename.includes('/blocks/')) {\n      return {}\n    }\n\n    return {\n      JSXOpeningElement(node: any) {\n        const elementName = node.name?.name\n\n        // Only check div elements\n        if (elementName !== 'div') {\n          return\n        }\n\n        // Check if className contains 'grid'\n        const classNameAttr = node.attributes?.find(\n          (attr: any) =>\n            attr.type === 'JSXAttribute' &&\n            attr.name?.name === 'className'\n        )\n\n        if (!classNameAttr) {\n          return\n        }\n\n        // Handle string literal className\n        if (classNameAttr.value?.type === 'Literal') {\n          const classValue = classNameAttr.value.value\n          if (typeof classValue === 'string' && hasGridClass(classValue)) {\n            context.report({\n              node,\n              messageId: 'useLayoutComponent',\n            })\n          }\n          return\n        }\n\n        // Handle template literal className\n        if (classNameAttr.value?.type === 'JSXExpressionContainer') {\n          const expr = classNameAttr.value.expression\n\n          // Direct template literal: className={`grid ...`}\n          if (expr.type === 'TemplateLiteral') {\n            const quasis = expr.quasis || []\n            for (const quasi of quasis) {\n              if (quasi.value?.raw && hasGridClass(quasi.value.raw)) {\n                context.report({\n                  node,\n                  messageId: 'useLayoutComponent',\n                })\n                return\n              }\n            }\n          }\n\n          // clsx call: className={clsx('grid', ...)}\n          if (expr.type === 'CallExpression') {\n            const args = expr.arguments || []\n            for (const arg of args) {\n              if (arg.type === 'Literal' && typeof arg.value === 'string') {\n                if (hasGridClass(arg.value)) {\n                  context.report({\n                    node,\n                    messageId: 'useLayoutComponent',\n                  })\n                  return\n                }\n              }\n              // Check template literals in clsx args\n              if (arg.type === 'TemplateLiteral') {\n                const quasis = arg.quasis || []\n                for (const quasi of quasis) {\n                  if (quasi.value?.raw && hasGridClass(quasi.value.raw)) {\n                    context.report({\n                      node,\n                      messageId: 'useLayoutComponent',\n                    })\n                    return\n                  }\n                }\n              }\n            }\n          }\n        }\n      },\n    }\n  },\n}\n\n/**\n * Check if a className string contains grid classes\n * Matches: 'grid', 'grid-cols-', etc.\n * Does NOT match: 'grid-area', component names with 'grid' in them\n */\nfunction hasGridClass(classString: string): boolean {\n  // Split by whitespace and check each class\n  const classes = classString.split(/\\s+/)\n  \n  for (const cls of classes) {\n    // Match standalone 'grid' or 'grid-cols-*' patterns\n    if (cls === 'grid' || cls.startsWith('grid-cols-')) {\n      return true\n    }\n  }\n  \n  return false\n}\n\nexport default rule\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gallop.software/canon",
-  "version": "2.0.2",
+  "version": "2.2.0",
   "type": "module",
   "description": "Gallop Canon - Architecture patterns, ESLint plugin, and CLI for template governance",
   "main": "dist/index.js",

package/patterns/018-layout-components.md

@@ -0,0 +1,85 @@
+# 018: Layout Components
+
+**Category:** Layout  
+**Status:** Stable  
+**Enforcement:** ESLint (`gallop/prefer-layout-components`)
+
+## Summary
+
+Use the `Grid` or `Columns` component instead of raw `<div>` elements with grid classes.
+
+## Rationale
+
+Raw `<div>` elements with grid classes bypass the design system's layout abstractions. The `Grid` and `Columns` components provide:
+
+- **Consistent defaults** for gaps, columns, and alignment
+- **Semantic intent** - code is more readable when intent is clear
+- **Centralized updates** - layout defaults can be updated in one place
+- **Reduced errors** - no need to remember all required grid classes
+
+## Bad
+
+```tsx
+<div className="grid grid-cols-3 gap-6">
+  <Card>...</Card>
+  <Card>...</Card>
+  <Card>...</Card>
+</div>
+
+<div className="grid grid-cols-1 lg:grid-cols-2 gap-8 items-center">
+  <div>Left content</div>
+  <div>Right content</div>
+</div>
+```
+
+## Good
+
+```tsx
+import { Grid, Columns, Column } from '@/components'
+
+<Grid cols="grid-cols-3" gap="gap-6">
+  <Card>...</Card>
+  <Card>...</Card>
+  <Card>...</Card>
+</Grid>
+
+<Columns>
+  <Column>Left content</Column>
+  <Column>Right content</Column>
+</Columns>
+```
+
+## Component Reference
+
+### Grid
+
+For multi-item grid layouts (3+ columns, card grids, galleries):
+
+```tsx
+<Grid
+  cols="grid-cols-1 lg:grid-cols-3"  // optional, defaults to 1 → 3
+  gap="gap-6"                         // optional, has sensible default
+>
+  {children}
+</Grid>
+```
+
+### Columns
+
+For two-column layouts with optional reversal:
+
+```tsx
+<Columns
+  cols="grid-cols-1 lg:grid-cols-2"  // optional
+  gap="gap-8"                         // optional
+  align="items-center"                // optional
+  reverseColumns={true}               // swap order on lg+
+>
+  <Column>Left</Column>
+  <Column>Right</Column>
+</Columns>
+```
+
+## Exceptions
+
+The rule only applies to files in `/blocks/`. Component files may use raw divs with grid when building the layout primitives themselves.

package/patterns/019-background-image-rounded.md

@@ -0,0 +1,52 @@
+# 019: Background Image Rounded
+
+**Category:** Components  
+**Status:** Stable  
+**Enforcement:** ESLint (`gallop/background-image-rounded`)
+
+## Summary
+
+When using the `Image` component as a background image (with `absolute inset-0` positioning), always set `rounded="rounded-none"`.
+
+## Rationale
+
+The Image component defaults to `rounded-lg` for rounded corners. When used as a full-bleed background image, these rounded corners:
+
+- **Cause visual artifacts** - corners get clipped unexpectedly
+- **Conflict with container rounding** - the parent container should control edge styling
+- **Create inconsistent edges** - background images should fill their container completely
+
+## Bad
+
+```tsx
+{/* Background image without rounded prop - uses default rounded-lg */}
+<Image
+  src="/images/hero-bg.jpg"
+  alt="Background"
+  className="absolute inset-0 w-full h-full object-cover"
+/>
+```
+
+## Good
+
+```tsx
+{/* Background image with explicit rounded-none */}
+<Image
+  src="/images/hero-bg.jpg"
+  alt="Background"
+  className="absolute inset-0 w-full h-full object-cover"
+  rounded="rounded-none"
+/>
+```
+
+## Detection
+
+The rule identifies background images by checking for:
+- `Image` component usage
+- `className` containing both `absolute` and `inset-0`
+
+When detected, the rule requires `rounded="rounded-none"` to be explicitly set.
+
+## Exceptions
+
+This rule only applies to files in `/blocks/`. Component files that implement background image patterns internally are not flagged.

package/schema.json

@@ -210,6 +210,26 @@
       "enforcement": "documentation",
       "rule": null,
       "summary": "PageMetadata structure, structured data"
+    },
+    {
+      "id": "018",
+      "title": "Layout Components",
+      "file": "patterns/018-layout-components.md",
+      "category": "layout",
+      "status": "stable",
+      "enforcement": "eslint",
+      "rule": "gallop/prefer-layout-components",
+      "summary": "Use Grid/Columns, not raw div with grid"
+    },
+    {
+      "id": "019",
+      "title": "Background Image Rounded",
+      "file": "patterns/019-background-image-rounded.md",
+      "category": "components",
+      "status": "stable",
+      "enforcement": "eslint",
+      "rule": "gallop/background-image-rounded",
+      "summary": "Background images must have rounded=\"rounded-none\""
     }
   ],
   "guarantees": [
@@ -239,7 +259,7 @@
       "name": "Design System Compliance",
       "since": "1.0.0",
       "status": "stable",
-      "patterns": ["003", "004", "009", "010", "011"]
+      "patterns": ["003", "004", "009", "010", "011", "018", "019"]
     }
   ]
 }