@empline/preflight 1.1.14 → 1.1.15

package/dist/checks/system/layout-constants-sync.js

@@ -0,0 +1,642 @@
+#!/usr/bin/env tsx
+"use strict";
+/**
+ * Layout Constants Sync Preflight - IRON-CLAD ENFORCEMENT
+ *
+ * Ensures consistency between:
+ * 1. Shared layout constants (single source of truth)
+ * 2. Actual layout component implementations
+ * 3. Preflights that reference layout components
+ * 4. Identifies opportunities for consolidation (shown as warnings)
+ *
+ * This prevents drift where constants say one thing but implementations do another.
+ *
+ * Usage:
+ *   pnpm preflight:layout-constants-sync           # All checks including opportunities
+ *   pnpm preflight:layout-constants-sync --verbose # Show all details
+ *
+ * Checks performed:
+ *   1. Layout components implement expected gap values (BLOCKING)
+ *   2. Preflights import from shared constants (not hardcoded)
+ *   3. All registered components exist (BLOCKING)
+ *   4. Unregistered gap layouts are flagged
+ *   5. Hardcoded spacing that could use constants (WARNING)
+ *   6. Components that could benefit from shared constants (WARNING)
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requires = exports.tags = exports.description = exports.blocking = exports.category = exports.name = exports.id = void 0;
+exports.run = run;
+const fs = __importStar(require("fs"));
+const console_chars_1 = require("../../utils/console-chars");
+const file_cache_1 = require("../../shared/file-cache");
+const glob_patterns_1 = require("../../shared/glob-patterns");
+const universal_progress_reporter_1 = require("./universal-progress-reporter");
+// Check metadata
+exports.id = "system/layout-constants-sync";
+exports.name = "Layout Constants Sync";
+exports.category = "system";
+exports.blocking = true;
+exports.description = "Layout Constants Sync Preflight - IRON-CLAD ENFORCEMENT";
+exports.tags = ["system"];
+exports.requires = ["trading-card-system"];
+// Dynamic imports for project-specific modules
+let GAP_LAYOUT_COMPONENTS = [];
+let LAYOUT_GAP_SPACING = 6;
+let LAYOUT_PADDING_TOP_SPACING = 4;
+let TOAST_CONTAINER_GAP_SPACING = 3;
+async function loadProjectDependencies() {
+    try {
+        const layoutConstantsPath = "../../shared/layout-constants";
+        const mod = await Promise.resolve(`${layoutConstantsPath}`).then(s => __importStar(require(s)));
+        GAP_LAYOUT_COMPONENTS = mod.GAP_LAYOUT_COMPONENTS;
+        LAYOUT_GAP_SPACING = mod.LAYOUT_GAP_SPACING;
+        LAYOUT_PADDING_TOP_SPACING = mod.LAYOUT_PADDING_TOP_SPACING;
+        TOAST_CONTAINER_GAP_SPACING = mod.TOAST_CONTAINER_GAP_SPACING;
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// CACHED FILE LISTS - Scan once, use everywhere
+let _cachedPreflightFiles = null;
+async function getPreflightFiles() {
+    if (!_cachedPreflightFiles) {
+        _cachedPreflightFiles = await file_cache_1.fileCache.getFiles("scripts/active/preflights/**/*.ts", {
+            ignore: glob_patterns_1.STANDARD_EXCLUDES,
+        });
+    }
+    return _cachedPreflightFiles;
+}
+let _cachedAppComponentsTsxFiles = null;
+async function getAppComponentsTsxFiles() {
+    if (!_cachedAppComponentsTsxFiles) {
+        _cachedAppComponentsTsxFiles = await file_cache_1.fileCache.getAppAndComponentsTSX();
+    }
+    return _cachedAppComponentsTsxFiles;
+}
+let _cachedLayoutFiles = null;
+async function getLayoutComponentFiles() {
+    if (!_cachedLayoutFiles) {
+        _cachedLayoutFiles = await file_cache_1.fileCache.getFiles("components/**/*Layout*.tsx", {
+            ignore: glob_patterns_1.STANDARD_EXCLUDES,
+        });
+    }
+    return _cachedLayoutFiles;
+}
+const EXCLUDED = [...glob_patterns_1.STANDARD_EXCLUDES];
+/**
+ * Check 1: Verify layout components actually use the expected gap value
+ *
+ * Note: Some layout components are thin wrappers around DashboardPageLayout.
+ * These wrappers don't define gap themselves - they delegate to DashboardPageLayout.
+ * We only check components that actually define their own gap.
+ */
+async function checkLayoutComponentsImplementGap() {
+    const issues = [];
+    // Map component names to their file paths
+    const componentFiles = {
+        DashboardPageLayout: "components/shared/DashboardPageLayout.tsx",
+        AdminPageLayout: "components/shared/AdminPageLayout.tsx",
+        SellerPageLayout: "components/shared/SellerPageLayout.tsx",
+        AccountPageLayout: "components/shared/AccountPageLayout.tsx",
+    };
+    // Components that are thin wrappers - they use DashboardPageLayout internally
+    // These don't need their own gap definition
+    const wrapperComponents = new Set([
+        "AdminPageLayout",
+        "SellerPageLayout",
+        "AccountPageLayout",
+        "TemplatesLayout",
+    ]);
+    for (const component of GAP_LAYOUT_COMPONENTS) {
+        const filePath = componentFiles[component];
+        if (!filePath || !fs.existsSync(filePath)) {
+            // Skip wrapper components like TemplatesLayout - they use the base layouts
+            continue;
+        }
+        const content = fs.readFileSync(filePath, "utf8");
+        // Check if this is a wrapper that delegates to DashboardPageLayout
+        const isDelegatingWrapper = wrapperComponents.has(component) && content.includes("DashboardPageLayout");
+        if (isDelegatingWrapper) {
+            // Verify it actually uses DashboardPageLayout
+            if (!/<DashboardPageLayout/.test(content)) {
+                issues.push({
+                    file: filePath,
+                    type: "wrapper-not-delegating",
+                    severity: "error",
+                    message: `${component} is expected to wrap DashboardPageLayout but doesn't`,
+                    suggestion: `Use <DashboardPageLayout variant="..."> inside ${component}`,
+                });
+            }
+            // Skip gap/padding checks for wrappers - DashboardPageLayout handles it
+            continue;
+        }
+        // Check for gap: var(--spacing-X) where X should match LAYOUT_GAP_SPACING
+        const gapMatches = content.matchAll(/gap:\s*["']var\(--spacing-(\d+)\)["']/g);
+        let foundCorrectGap = false;
+        for (const match of gapMatches) {
+            const gapValue = parseInt(match[1]);
+            if (gapValue === LAYOUT_GAP_SPACING) {
+                foundCorrectGap = true;
+            }
+            else {
+                const lineNumber = content.substring(0, match.index).split("\n").length;
+                issues.push({
+                    file: filePath,
+                    line: lineNumber,
+                    type: "layout-wrong-gap",
+                    severity: "error",
+                    message: `${component} uses gap: spacing-${gapValue} but shared constant expects spacing-${LAYOUT_GAP_SPACING}`,
+                    suggestion: `Change to gap: "var(--spacing-${LAYOUT_GAP_SPACING})" or update LAYOUT_GAP_SPACING in layout-constants.ts`,
+                });
+            }
+        }
+        // Check for paddingTop: var(--spacing-X) where X should match LAYOUT_PADDING_TOP_SPACING
+        const paddingMatches = content.matchAll(/paddingTop:\s*["']var\(--spacing-(\d+)\)["']/g);
+        for (const match of paddingMatches) {
+            const paddingValue = parseInt(match[1]);
+            if (paddingValue !== LAYOUT_PADDING_TOP_SPACING) {
+                const lineNumber = content.substring(0, match.index).split("\n").length;
+                issues.push({
+                    file: filePath,
+                    line: lineNumber,
+                    type: "layout-wrong-padding-top",
+                    severity: "error",
+                    message: `${component} uses paddingTop: spacing-${paddingValue} but shared constant expects spacing-${LAYOUT_PADDING_TOP_SPACING}`,
+                    suggestion: `Change to paddingTop: "var(--spacing-${LAYOUT_PADDING_TOP_SPACING})" or update LAYOUT_PADDING_TOP_SPACING in layout-constants.ts`,
+                });
+            }
+        }
+        // Warn if no gap found at all (only for non-wrapper components)
+        if (!foundCorrectGap && !content.includes(`gap:`)) {
+            issues.push({
+                file: filePath,
+                type: "layout-missing-gap",
+                severity: "warning",
+                message: `${component} is in GAP_LAYOUT_COMPONENTS but doesn't appear to use gap spacing`,
+                suggestion: `Add gap: "var(--spacing-${LAYOUT_GAP_SPACING})" to the content area style`,
+            });
+        }
+    }
+    return issues;
+}
+/**
+ * Check 2: Verify preflights import from shared constants (not hardcoded)
+ */
+async function checkPreflightsUseSharedConstants() {
+    const issues = [];
+    // Find all preflight files that might reference layout components
+    const preflightFiles = await getPreflightFiles();
+    // Skip the shared constants file itself
+    const sharedConstantsPath = "scripts/active/preflights/shared/layout-constants.ts";
+    for (const file of preflightFiles) {
+        if (file.replace(/\\/g, "/").includes("shared/layout-constants"))
+            continue;
+        const content = fs.readFileSync(file, "utf8");
+        const lines = content.split("\n");
+        // Check for hardcoded layout component arrays
+        const hardcodedPatterns = [
+            /const\s+\w*[Ll]ayout[Cc]omponents?\w*\s*=\s*\[/,
+            /const\s+GAP_LAYOUTS\s*=\s*\[(?!\.\.\.GAP_LAYOUT_COMPONENTS)/,
+            /const\s+LAYOUT_COMPONENTS_WITH_GAP\s*=\s*\[(?!\.\.\.GAP_LAYOUT_COMPONENTS)/,
+        ];
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            for (const pattern of hardcodedPatterns) {
+                if (pattern.test(line)) {
+                    // Check if this file imports from shared constants
+                    const hasSharedImport = content.includes("from '../shared/layout-constants'") ||
+                        content.includes("from './shared/layout-constants'") ||
+                        content.includes("from '../../shared/layout-constants'");
+                    if (!hasSharedImport) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "hardcoded-layout-list",
+                            severity: "warning",
+                            message: "Preflight has hardcoded layout component list instead of using shared constants",
+                            suggestion: "Import GAP_LAYOUT_COMPONENTS from '../shared/layout-constants' and use it",
+                        });
+                    }
+                }
+            }
+        }
+        // Check for hardcoded spacing values that should use constants
+        const spacingPatterns = [
+            { pattern: /DASHBOARD_LAYOUT_PADDING_TOP:\s*(\d+)/, name: "DASHBOARD_LAYOUT_PADDING_TOP" },
+            { pattern: /LAYOUT_GAP_SPACING\s*=\s*(\d+)/, name: "LAYOUT_GAP_SPACING" },
+        ];
+        for (const { pattern, name } of spacingPatterns) {
+            const match = content.match(pattern);
+            if (match && !file.includes("layout-constants")) {
+                const hasSharedImport = content.includes("from '../shared/layout-constants'") ||
+                    content.includes("from './shared/layout-constants'");
+                if (!hasSharedImport) {
+                    issues.push({
+                        file,
+                        type: "hardcoded-spacing-value",
+                        severity: "warning",
+                        message: `Preflight defines ${name} locally instead of importing from shared constants`,
+                        suggestion: `Import ${name} from layout-constants.ts`,
+                    });
+                }
+            }
+        }
+    }
+    return issues;
+}
+/**
+ * Check 3: Verify all layout components in GAP_LAYOUT_COMPONENTS actually exist
+ */
+async function checkLayoutComponentsExist() {
+    const issues = [];
+    // Find all component files
+    const componentFiles = await getAppComponentsTsxFiles();
+    const componentNames = new Set();
+    for (const file of componentFiles) {
+        const content = fs.readFileSync(file, "utf8");
+        // Extract exported component names
+        const exportMatches = content.matchAll(/export\s+(?:default\s+)?function\s+(\w+)/g);
+        for (const match of exportMatches) {
+            componentNames.add(match[1]);
+        }
+        // Also check for const exports
+        const constExportMatches = content.matchAll(/export\s+(?:const|let)\s+(\w+)/g);
+        for (const match of constExportMatches) {
+            componentNames.add(match[1]);
+        }
+    }
+    // Check each component in GAP_LAYOUT_COMPONENTS exists
+    for (const component of GAP_LAYOUT_COMPONENTS) {
+        if (!componentNames.has(component)) {
+            issues.push({
+                file: "scripts/active/preflights/shared/layout-constants.ts",
+                type: "missing-layout-component",
+                severity: "error",
+                message: `GAP_LAYOUT_COMPONENTS includes "${component}" but this component doesn't exist`,
+                suggestion: `Remove "${component}" from GAP_LAYOUT_COMPONENTS or create the component`,
+            });
+        }
+    }
+    return issues;
+}
+/**
+ * Check 4: Find layout components that use gap but aren't in GAP_LAYOUT_COMPONENTS
+ */
+async function checkUnregisteredGapLayouts() {
+    const issues = [];
+    // Find layout component files
+    const layoutFiles = await getLayoutComponentFiles();
+    for (const file of layoutFiles) {
+        const content = fs.readFileSync(file, "utf8");
+        // Check if this file defines a gap-based layout
+        const hasGap = /gap:\s*["']var\(--spacing-\d+\)["']/.test(content);
+        const hasFlexColumn = /flexDirection:\s*["']column["']/.test(content) || /flex-col/.test(content);
+        if (hasGap && hasFlexColumn) {
+            // Extract component name from file
+            const componentMatch = content.match(/export\s+(?:default\s+)?function\s+(\w*Layout\w*)/);
+            if (componentMatch) {
+                const componentName = componentMatch[1];
+                // Check if it's in GAP_LAYOUT_COMPONENTS
+                if (!GAP_LAYOUT_COMPONENTS.includes(componentName)) {
+                    issues.push({
+                        file,
+                        type: "unregistered-gap-layout",
+                        severity: "warning",
+                        message: `${componentName} uses gap spacing but isn't in GAP_LAYOUT_COMPONENTS`,
+                        suggestion: `Add "${componentName}" to GAP_LAYOUT_COMPONENTS in layout-constants.ts if children shouldn't have margin`,
+                    });
+                }
+            }
+        }
+    }
+    return issues;
+}
+/**
+ * Check 4b: Verify toast/notification containers have proper gap spacing
+ *
+ * Toast containers should use gap: var(--spacing-3) to ensure consistent
+ * spacing between stacked notifications in the upper right corner.
+ */
+async function checkToastContainerGaps() {
+    const issues = [];
+    // Files that contain toast container implementations
+    const toastContainerFiles = [
+        "components/shared/status/StatusProvider.tsx",
+        "components/ToastProvider.tsx",
+        "components/shared/notifications/Toast.tsx",
+        "components/shared/notifications/NotificationProvider.tsx",
+        "packages/ui/src/components/feedback/Toast.tsx",
+    ];
+    for (const filePath of toastContainerFiles) {
+        if (!fs.existsSync(filePath))
+            continue;
+        const content = fs.readFileSync(filePath, "utf8");
+        const lines = content.split("\n");
+        // Check for flex-col containers that render multiple toasts/notifications
+        // These should have gap spacing
+        const flexColContainerPatterns = [
+            /flexDirection:\s*["']column["']/,
+            /flex-col/,
+            /flex\s+flex-col/,
+        ];
+        const hasFlexColumn = flexColContainerPatterns.some((p) => p.test(content));
+        // Check if file renders multiple toast items (map over toasts/notifications)
+        const rendersMultipleToasts = /\.map\s*\(\s*\(?\s*(?:toast|notification|item)/i.test(content) ||
+            /toasts\.map|notifications\.map/i.test(content);
+        if (hasFlexColumn && rendersMultipleToasts) {
+            // Check for gap in the container
+            const hasGapStyle = /gap:\s*["']var\(--spacing-(\d+)\)["']/.test(content);
+            const hasGapClass = /gap-(\d+)/.test(content);
+            if (!hasGapStyle && !hasGapClass) {
+                issues.push({
+                    file: filePath,
+                    type: "toast-container-missing-gap",
+                    severity: "error",
+                    message: `Toast container missing gap spacing between stacked items`,
+                    suggestion: `Add gap: "var(--spacing-${TOAST_CONTAINER_GAP_SPACING})" or className="gap-${TOAST_CONTAINER_GAP_SPACING}" to the flex-col container`,
+                });
+            }
+            else {
+                // Verify correct gap value
+                const styleGapMatch = content.match(/gap:\s*["']var\(--spacing-(\d+)\)["']/);
+                const classGapMatch = content.match(/gap-(\d+)/);
+                const gapValue = styleGapMatch
+                    ? parseInt(styleGapMatch[1])
+                    : classGapMatch
+                        ? parseInt(classGapMatch[1])
+                        : null;
+                if (gapValue !== null && gapValue !== TOAST_CONTAINER_GAP_SPACING) {
+                    // Find line number
+                    let lineNumber = 0;
+                    for (let i = 0; i < lines.length; i++) {
+                        if (/gap/.test(lines[i]) &&
+                            /toast|notification/i.test(content.slice(0, content.indexOf(lines[i])))) {
+                            lineNumber = i + 1;
+                            break;
+                        }
+                    }
+                    issues.push({
+                        file: filePath,
+                        line: lineNumber || undefined,
+                        type: "toast-container-wrong-gap",
+                        severity: "warning",
+                        message: `Toast container uses gap-${gapValue} but expected gap-${TOAST_CONTAINER_GAP_SPACING}`,
+                        suggestion: `Change to gap: "var(--spacing-${TOAST_CONTAINER_GAP_SPACING})" or className="gap-${TOAST_CONTAINER_GAP_SPACING}"`,
+                    });
+                }
+            }
+        }
+    }
+    return issues;
+}
+/**
+ * Check 5: Find opportunities where hardcoded spacing values could use shared constants
+ *
+ * Scans components for patterns like:
+ * - gap: "var(--spacing-X)" that could use SPACING constants
+ * - padding: "var(--spacing-X)" that could use SPACING constants
+ * - Hardcoded layout component name arrays
+ *
+ * These are shown as WARNINGS to encourage consolidation.
+ */
+async function checkSharedConstantOpportunities() {
+    const issues = [];
+    // Scan component files (not preflights - those are checked separately)
+    const componentFiles = await getAppComponentsTsxFiles();
+    // Spacing patterns to detect with their suggested constants
+    const spacingOpportunities = [
+        { value: 2, type: "gap", constant: "SPACING.COMPACT_GAP", minOccurrences: 2 },
+        { value: 3, type: "gap", constant: "SPACING.CARD_CONTAINER_GAP", minOccurrences: 2 },
+        { value: 6, type: "gap", constant: "SPACING.SECTION_GAP", minOccurrences: 2 },
+        { value: 4, type: "padding", constant: "SPACING.CONTENT_PADDING", minOccurrences: 3 },
+        { value: 6, type: "padding", constant: "SPACING.CARD_PADDING", minOccurrences: 2 },
+    ];
+    for (const file of componentFiles) {
+        // Skip layout files themselves - they're the source of truth
+        if (file.includes("Layout") && file.includes("components/shared"))
+            continue;
+        // Skip DashboardPageLayout specifically - it's the canonical source
+        if (file.includes("DashboardPageLayout"))
+            continue;
+        const content = fs.readFileSync(file, "utf8");
+        // Skip if file already imports SPACING from lib/constants
+        if (content.includes("from '@/lib/constants/spacing'") ||
+            content.includes('from "@/lib/constants/spacing"') ||
+            content.includes("from '@/lib/constants'") ||
+            content.includes('from "@/lib/constants"')) {
+            continue;
+        }
+        // Check each spacing pattern
+        for (const { value, type, constant, minOccurrences } of spacingOpportunities) {
+            const pattern = new RegExp(`${type}:\\s*["']var\\(--spacing-${value}\\)["']`, "g");
+            const matches = [...content.matchAll(pattern)];
+            if (matches.length >= minOccurrences) {
+                issues.push({
+                    file,
+                    type: `hardcoded-${type}-spacing-${value}`,
+                    severity: "warning",
+                    message: `${matches.length}x ${type}: "var(--spacing-${value})" ${console_chars_1.chars.arrow} use ${constant}`,
+                    suggestion: `Import { SPACING } from '@/lib/constants/spacing'`,
+                });
+            }
+        }
+        // Check for files that define their own SPACING constants
+        if (/const\s+SPACING\s*=\s*\{/.test(content) && !file.includes("lib/constants")) {
+            issues.push({
+                file,
+                type: "duplicate-spacing-constant",
+                severity: "warning",
+                message: "Local SPACING constant - import from lib/constants/spacing instead",
+                suggestion: "Import { SPACING } from '@/lib/constants/spacing'",
+            });
+        }
+        // Check for hardcoded layout component arrays
+        if (/const\s+\w*(?:layouts?|pageLayouts?)\w*\s*=\s*\[\s*["'](?:Admin|Seller|Account|Dashboard)PageLayout["']/i.test(content)) {
+            issues.push({
+                file,
+                type: "hardcoded-layout-array",
+                severity: "warning",
+                message: "Hardcoded layout array - import GAP_LAYOUT_COMPONENTS",
+                suggestion: "Import from scripts/active/preflights/shared/layout-constants",
+            });
+        }
+    }
+    return issues;
+}
+/**
+ * Check 6: Find components using layout components that might benefit from shared constants
+ */
+async function checkLayoutConsumerOpportunities() {
+    const issues = [];
+    const componentFiles = await getAppComponentsTsxFiles();
+    // Skip wrapper layout files - they legitimately use DashboardPageLayout
+    const wrapperFiles = ["AdminPageLayout", "SellerPageLayout", "AccountPageLayout"];
+    for (const file of componentFiles) {
+        const content = fs.readFileSync(file, "utf8");
+        // Skip if file already imports from layout-constants or lib/constants
+        if (content.includes("layout-constants") || content.includes("from '@/lib/constants"))
+            continue;
+        // Skip wrapper layout files
+        if (wrapperFiles.some((wrapper) => file.includes(wrapper)))
+            continue;
+        // Check if file uses multiple layout components (excluding wrapper patterns)
+        const layoutUsageCount = GAP_LAYOUT_COMPONENTS.filter((comp) => new RegExp(`<${comp}[\\s>]`).test(content)).length;
+        // Only flag if using 3+ different layouts (2 is common for wrapper pattern)
+        if (layoutUsageCount >= 3) {
+            issues.push({
+                file,
+                type: "multiple-layout-usage",
+                severity: "warning",
+                message: `Uses ${layoutUsageCount} different layout components - might benefit from shared constants`,
+                suggestion: "If checking layout types, consider importing GAP_LAYOUT_COMPONENTS",
+            });
+        }
+        // Check for switch/if statements checking layout component names
+        const layoutSwitchPattern = /(?:switch|if)\s*\([^)]*(?:Admin|Seller|Account|Dashboard)PageLayout/;
+        if (layoutSwitchPattern.test(content)) {
+            issues.push({
+                file,
+                type: "layout-type-checking",
+                severity: "warning",
+                message: "Contains layout type checking logic - could use GAP_LAYOUT_COMPONENTS",
+                suggestion: "Import GAP_LAYOUT_COMPONENTS for type-safe layout checking",
+            });
+        }
+    }
+    return issues;
+}
+async function run() {
+    const reporter = (0, universal_progress_reporter_1.createUniversalProgressReporter)(exports.name);
+    // Load project-specific dependencies
+    const loaded = await loadProjectDependencies();
+    if (!loaded) {
+        console.log(`${console_chars_1.emoji.skip} Skipping: project-specific modules not available`);
+        return { passed: true, skipped: true };
+    }
+    const args = process.argv.slice(2);
+    const verbose = args.includes("--verbose") || args.includes("-v");
+    console.log(`\n${console_chars_1.emoji.refresh} LAYOUT CONSTANTS SYNC PREFLIGHT`);
+    console.log(`${console_chars_1.box.doubleHorizontal}`.repeat(70));
+    console.log(`Shared Constants: GAP_LAYOUT_COMPONENTS has ${GAP_LAYOUT_COMPONENTS.length} components`);
+    console.log(`Expected Gap: spacing-${LAYOUT_GAP_SPACING} (${LAYOUT_GAP_SPACING * 4}px)`);
+    console.log(`Expected PaddingTop: spacing-${LAYOUT_PADDING_TOP_SPACING} (${LAYOUT_PADDING_TOP_SPACING * 4}px)`);
+    console.log(`${console_chars_1.box.doubleHorizontal}`.repeat(70));
+    const allIssues = [];
+    // Run core checks (always run)
+    console.log(`\n${console_chars_1.emoji.search} Checking layout component implementations...`);
+    const implIssues = await checkLayoutComponentsImplementGap();
+    allIssues.push(...implIssues);
+    console.log(`   Found ${implIssues.length} issue(s)`);
+    console.log(`${console_chars_1.emoji.search} Checking preflights use shared constants...`);
+    const preflightIssues = await checkPreflightsUseSharedConstants();
+    allIssues.push(...preflightIssues);
+    console.log(`   Found ${preflightIssues.length} issue(s)`);
+    console.log(`${console_chars_1.emoji.search} Checking all registered components exist...`);
+    const existIssues = await checkLayoutComponentsExist();
+    allIssues.push(...existIssues);
+    console.log(`   Found ${existIssues.length} issue(s)`);
+    console.log(`${console_chars_1.emoji.search} Checking for unregistered gap layouts...`);
+    const unregisteredIssues = await checkUnregisteredGapLayouts();
+    allIssues.push(...unregisteredIssues);
+    console.log(`   Found ${unregisteredIssues.length} issue(s)`);
+    console.log(`${console_chars_1.emoji.search} Checking toast container gap spacing...`);
+    const toastGapIssues = await checkToastContainerGaps();
+    allIssues.push(...toastGapIssues);
+    console.log(`   Found ${toastGapIssues.length} issue(s)`);
+    // Run opportunity checks (always run - shown as warnings)
+    console.log(`${console_chars_1.emoji.search} Scanning for consolidation opportunities...`);
+    const constantOpportunities = await checkSharedConstantOpportunities();
+    const consumerOpportunities = await checkLayoutConsumerOpportunities();
+    allIssues.push(...constantOpportunities, ...consumerOpportunities);
+    console.log(`   Found ${constantOpportunities.length + consumerOpportunities.length} opportunity warning(s)`);
+    // Report results
+    const errors = allIssues.filter((i) => i.severity === "error");
+    const warnings = allIssues.filter((i) => i.severity === "warning");
+    if (errors.length === 0 && warnings.length === 0) {
+        console.log(`\n${console_chars_1.emoji.success} Layout constants are in sync!`);
+        console.log(`${console_chars_1.box.doubleHorizontal}`.repeat(70));
+        process.exit(0);
+    }
+    // Print issues grouped by severity
+    if (errors.length > 0 || warnings.length > 0) {
+        console.log(`\n${console_chars_1.emoji.error} Found ${errors.length} error(s), ${warnings.length} warning(s):\n`);
+    }
+    // Group by file
+    const byFile = new Map();
+    for (const issue of allIssues) {
+        const existing = byFile.get(issue.file) || [];
+        existing.push(issue);
+        byFile.set(issue.file, existing);
+    }
+    for (const [file, fileIssues] of byFile) {
+        const fileErrors = fileIssues.filter((i) => i.severity === "error");
+        const fileWarnings = fileIssues.filter((i) => i.severity === "warning");
+        if (fileErrors.length > 0 || fileWarnings.length > 0) {
+            console.log(`${console_chars_1.emoji.folder} ${file}`);
+            for (const issue of [...fileErrors, ...fileWarnings]) {
+                const icon = issue.severity === "error" ? console_chars_1.emoji.error : console_chars_1.emoji.warning;
+                console.log(`   ${icon} ${issue.line ? `Line ${issue.line}: ` : ""}${issue.message}`);
+                if (issue.suggestion && verbose) {
+                    console.log(`      ${console_chars_1.box.bottomLeft}${console_chars_1.box.horizontal} ${issue.suggestion}`);
+                }
+            }
+            console.log();
+        }
+    }
+    console.log(`${console_chars_1.box.doubleHorizontal}`.repeat(70));
+    if (errors.length > 0) {
+        console.log(`${console_chars_1.emoji.error} FAILED: ${errors.length} error(s) must be fixed`);
+        process.exit(1);
+    }
+    else if (warnings.length > 0) {
+        console.log(`${console_chars_1.emoji.warning} PASSED with ${warnings.length} warning(s) - consider using shared constants`);
+        if (!verbose) {
+            console.log(`${console_chars_1.emoji.hint} Run with --verbose to see suggestions`);
+        }
+        process.exit(0);
+    }
+    else {
+        console.log(`${console_chars_1.emoji.success} Layout constants are in sync!`);
+        process.exit(0);
+    }
+}
+// Allow direct execution
+if (require.main === module) {
+    run().catch(console.error);
+}
+//# sourceMappingURL=layout-constants-sync.js.map