@schemyx/mcp 0.1.1 → 0.1.3

package/dist/codebase-scanner/bundle.js

@@ -4,7 +4,15 @@ exports.createBundle = createBundle;
 exports.addEntry = addEntry;
 exports.hasStyleSurface = hasStyleSurface;
 exports.isBackendRouteFile = isBackendRouteFile;
+exports.hasDatabaseSurface = hasDatabaseSurface;
+exports.addDatabaseSurfaceEntries = addDatabaseSurfaceEntries;
+exports.databaseSurfaceText = databaseSurfaceText;
+exports.databaseSurfaceConfidence = databaseSurfaceConfidence;
+exports.databaseAccessDependencies = databaseAccessDependencies;
+exports.databaseAccessEdgeType = databaseAccessEdgeType;
+exports.databaseEnumKey = databaseEnumKey;
 exports.backendFileContext = backendFileContext;
+exports.databaseFileContext = databaseFileContext;
 exports.findEndpointContract = findEndpointContract;
 exports.createBackendEndpointFlow = createBackendEndpointFlow;
 exports.backendCallDependencies = backendCallDependencies;
@@ -15,8 +23,99 @@ exports.sourceInfo = sourceInfo;
 exports.toGraphNode = toGraphNode;
 exports.toGraphEdge = toGraphEdge;
 exports.addRenderEdges = addRenderEdges;
+exports.inferStyleDefinitionVariantRoles = inferStyleDefinitionVariantRoles;
+exports.inferActionVariantRole = inferActionVariantRole;
+exports.createStyleDefinitionGuidance = createStyleDefinitionGuidance;
+exports.summarizeUiElementPatterns = summarizeUiElementPatterns;
+exports.uiElementPatternUsage = uiElementPatternUsage;
+exports.rootUiElementsForKind = rootUiElementsForKind;
+exports.isLayoutSafetyProfile = isLayoutSafetyProfile;
+exports.isResponsiveProfile = isResponsiveProfile;
+exports.isScaleProfile = isScaleProfile;
+exports.isSemanticProfile = isSemanticProfile;
+exports.createStyleResolutionContext = createStyleResolutionContext;
+exports.detectProjectStyleSystems = detectProjectStyleSystems;
+exports.classNamesFromCssSelector = classNamesFromCssSelector;
+exports.unescapeCssIdentifier = unescapeCssIdentifier;
+exports.cssSelectorStatePrefixes = cssSelectorStatePrefixes;
+exports.cssRuleMediaContext = cssRuleMediaContext;
+exports.normalizeCssDeclarationValue = normalizeCssDeclarationValue;
+exports.cssDeclarationImportant = cssDeclarationImportant;
+exports.estimateSelectorSpecificity = estimateSelectorSpecificity;
+exports.resolveCssValueTokens = resolveCssValueTokens;
+exports.resolveUiClassDeclarations = resolveUiClassDeclarations;
+exports.tailwindDeclarationsForClass = tailwindDeclarationsForClass;
+exports.tailwindAlignmentDeclaration = tailwindAlignmentDeclaration;
+exports.tailwindSpacingDeclaration = tailwindSpacingDeclaration;
+exports.tailwindSizingDeclaration = tailwindSizingDeclaration;
+exports.tailwindTypographyDeclaration = tailwindTypographyDeclaration;
+exports.tailwindBorderDeclaration = tailwindBorderDeclaration;
+exports.tailwindColorDeclaration = tailwindColorDeclaration;
+exports.tailwindColorValue = tailwindColorValue;
+exports.cssTokenValue = cssTokenValue;
+exports.colorKeywordValue = colorKeywordValue;
+exports.opacityToPercent = opacityToPercent;
+exports.tailwindScaleValue = tailwindScaleValue;
+exports.tailwindNamedSizeValue = tailwindNamedSizeValue;
+exports.arbitraryTokenValue = arbitraryTokenValue;
+exports.arbitraryValue = arbitraryValue;
+exports.looksLikeCssLength = looksLikeCssLength;
+exports.tailwindShadowValue = tailwindShadowValue;
+exports.bootstrapDeclarationsForClass = bootstrapDeclarationsForClass;
+exports.isBootstrapClass = isBootstrapClass;
+exports.bootstrapResponsivePrefixes = bootstrapResponsivePrefixes;
+exports.stripBootstrapResponsiveInfix = stripBootstrapResponsiveInfix;
+exports.bootstrapComponentDeclarations = bootstrapComponentDeclarations;
+exports.bootstrapSpacingDeclarations = bootstrapSpacingDeclarations;
+exports.bootstrapDisplayDeclarations = bootstrapDisplayDeclarations;
+exports.bootstrapFlexDeclarations = bootstrapFlexDeclarations;
+exports.bootstrapSizingDeclarations = bootstrapSizingDeclarations;
+exports.bootstrapTypographyDeclarations = bootstrapTypographyDeclarations;
+exports.bootstrapColorDeclarations = bootstrapColorDeclarations;
+exports.bootstrapBorderDeclarations = bootstrapBorderDeclarations;
+exports.bootstrapGridDeclarations = bootstrapGridDeclarations;
+exports.categorizeResolvedStyleDeclarations = categorizeResolvedStyleDeclarations;
+exports.flattenResolvedStyleCategories = flattenResolvedStyleCategories;
+exports.createStyleSystemEvidence = createStyleSystemEvidence;
+exports.isLikelyTailwindClass = isLikelyTailwindClass;
+exports.resolvedStyleCategory = resolvedStyleCategory;
+exports.mergeResolvedStyleCategories = mergeResolvedStyleCategories;
+exports.classBucketRecord = classBucketRecord;
+exports.resolvedStyleRecord = resolvedStyleRecord;
+exports.createUiContract = createUiContract;
+exports.createUiContractForElement = createUiContractForElement;
+exports.createUiContractForChild = createUiContractForChild;
+exports.createUiPatternContract = createUiPatternContract;
+exports.createUiRelationships = createUiRelationships;
+exports.createUiResponsiveVariants = createUiResponsiveVariants;
+exports.createUiInteractionVariants = createUiInteractionVariants;
+exports.uiContractClassBucket = uiContractClassBucket;
+exports.mergeUiContractClassBuckets = mergeUiContractClassBuckets;
+exports.filterUiContractClasses = filterUiContractClasses;
+exports.isResponsivePrefix = isResponsivePrefix;
+exports.responsivePrefixesForClass = responsivePrefixesForClass;
+exports.isInteractionPrefix = isInteractionPrefix;
+exports.omitEmptyRecord = omitEmptyRecord;
+exports.mergeLayoutSafetyProfiles = mergeLayoutSafetyProfiles;
+exports.mergeResponsiveProfiles = mergeResponsiveProfiles;
+exports.mergeScaleProfiles = mergeScaleProfiles;
+exports.mergeSemanticProfiles = mergeSemanticProfiles;
+exports.summarizePatternLayoutSafety = summarizePatternLayoutSafety;
+exports.summarizePatternResponsiveProfile = summarizePatternResponsiveProfile;
+exports.summarizePatternScaleProfile = summarizePatternScaleProfile;
+exports.summarizePatternSemanticProfile = summarizePatternSemanticProfile;
+exports.summarizePatternRoleSignatures = summarizePatternRoleSignatures;
+exports.summarizeParentContexts = summarizeParentContexts;
+exports.summarizeElementChildContract = summarizeElementChildContract;
+exports.summarizePatternChildStructure = summarizePatternChildStructure;
+exports.summarizeCompoundStructure = summarizeCompoundStructure;
+exports.createUiGenerationConstraints = createUiGenerationConstraints;
+exports.createUiGenerationGuidance = createUiGenerationGuidance;
+exports.summarizeActionUsages = summarizeActionUsages;
+exports.actionVariantNamesForElement = actionVariantNamesForElement;
 exports.addUiPatternRules = addUiPatternRules;
 exports.addUiCompositionRules = addUiCompositionRules;
+exports.addGlobalUiContractRules = addGlobalUiContractRules;
 exports.addConnectedPatternRules = addConnectedPatternRules;
 exports.buildConnectedPatternClusters = buildConnectedPatternClusters;
 exports.createFrontendPatternInstances = createFrontendPatternInstances;
@@ -26,7 +125,17 @@ exports.isConnectedUiPatternRoot = isConnectedUiPatternRoot;
 exports.normalizeConnectedChildren = normalizeConnectedChildren;
 exports.withoutConnectedChildSignature = withoutConnectedChildSignature;
 exports.connectedChildKind = connectedChildKind;
+exports.isRecordValue = isRecordValue;
+exports.isRoleSignatureRecord = isRoleSignatureRecord;
+exports.summarizeConnectedLayoutSafety = summarizeConnectedLayoutSafety;
+exports.summarizeConnectedResponsiveProfile = summarizeConnectedResponsiveProfile;
+exports.summarizeConnectedScaleProfile = summarizeConnectedScaleProfile;
+exports.summarizeConnectedSemanticProfile = summarizeConnectedSemanticProfile;
+exports.summarizeConnectedRoleSignatures = summarizeConnectedRoleSignatures;
+exports.summarizeConnectedCompoundStructure = summarizeConnectedCompoundStructure;
+exports.summarizeConnectedParentContexts = summarizeConnectedParentContexts;
 exports.summarizeConnectedChildren = summarizeConnectedChildren;
+exports.mergeChildVariants = mergeChildVariants;
 exports.compactConnectedPatternInstance = compactConnectedPatternInstance;
 exports.scoreConnectedPatternGroup = scoreConnectedPatternGroup;
 exports.connectedPatternConfidence = connectedPatternConfidence;
@@ -43,9 +152,11 @@ exports.frontendPatternWeight = frontendPatternWeight;
 exports.backendPatternWeight = backendPatternWeight;
 exports.hasBackendPatternSurface = hasBackendPatternSurface;
 exports.backendPatternConcept = backendPatternConcept;
+exports.databaseFieldShapeInputs = databaseFieldShapeInputs;
 exports.summarizeModelFieldShape = summarizeModelFieldShape;
 exports.createConnectedPatternGuidance = createConnectedPatternGuidance;
 exports.connectedPatternSlug = connectedPatternSlug;
+exports.roleSignatureKey = roleSignatureKey;
 exports.classSignature = classSignature;
 exports.normalizeLayoutRole = normalizeLayoutRole;
 exports.normalizeTagForSignature = normalizeTagForSignature;
@@ -54,13 +165,16 @@ exports.labelSignature = labelSignature;
 exports.addImportEdges = addImportEdges;
 exports.addApiCallEdges = addApiCallEdges;
 exports.addStyleUsageEdges = addStyleUsageEdges;
+exports.addDatabaseUsageEdges = addDatabaseUsageEdges;
 exports.addModelUsageEdges = addModelUsageEdges;
+exports.addDatabaseReviewItems = addDatabaseReviewItems;
 exports.addConceptClusters = addConceptClusters;
 exports.applyUsedBy = applyUsedBy;
 exports.detectProjectFacts = detectProjectFacts;
 exports.detectFrameworkForFile = detectFrameworkForFile;
 const backend_1 = require("./backend");
 const constants_1 = require("./constants");
+const database_1 = require("./database");
 const extractors_1 = require("./extractors");
 const utils_1 = require("./utils");
 function createBundle(rootPath, projectType, files) {
@@ -69,6 +183,7 @@ function createBundle(rootPath, projectType, files) {
     const nodes = [];
     const edges = [];
     const reviewItems = [];
+    const styleResolutionContext = createStyleResolutionContext(files);
     for (const file of files) {
         const fileSource = sourceInfo('core.files', 'high', [`path:${file.relPath}`], file);
         addEntry(entries, usedKeys, {
@@ -112,8 +227,12 @@ function createBundle(rootPath, projectType, files) {
                 middleware: file.middleware,
                 jobs: file.jobs,
                 events: file.events,
-                uiElements: file.uiElements.slice(0, 40),
+                uiElements: file.uiElements.slice(0, 80),
+                uiContracts: file.uiElements
+                    .slice(0, 80)
+                    .map((element) => createUiContractForElement(element, file, 'high', styleResolutionContext)),
                 ...backendFileContext(file),
+                ...databaseFileContext(file),
                 size: file.size,
                 sourceHash: file.sourceHash,
                 source: fileSource,
@@ -141,7 +260,7 @@ function createBundle(rootPath, projectType, files) {
             nodes.push(toGraphNode(dependencyKey, 'package', dependency, file.relPath, file, 'core.dependencies'));
             edges.push(toGraphEdge(file.key, dependencyKey, 'depends_on', 'core.dependencies', file));
         }
-        for (const component of file.components) {
+        for (const component of (0, extractors_1.isTestFile)(file.relPath) ? [] : file.components) {
             const componentKey = (0, utils_1.toRegistryKey)('component', component);
             const styleKey = (0, utils_1.toRegistryKey)('style', file.relPath.replace(/\.[^.]+$/, ''));
             const compositionRuleKey = (0, utils_1.toRegistryKey)('rule', `ui.composition.${file.relPath.replace(/\.[^.]+$/, '')}`);
@@ -171,7 +290,10 @@ function createBundle(rootPath, projectType, files) {
                     classExpressions: file.classExpressions.slice(0, 80),
                     componentStyleDefinitions: file.componentStyleDefinitions.slice(0, 20),
                     themeTokens: file.themeTokens.slice(0, 120),
-                    uiElements: file.uiElements.slice(0, 20),
+                    uiElements: file.uiElements.slice(0, 80),
+                    uiContracts: file.uiElements
+                        .slice(0, 80)
+                        .map((element) => createUiContractForElement(element, file, 'high', styleResolutionContext)),
                     apiCalls: file.apiCalls,
                     authHints: file.authHints,
                     kind: 'component',
@@ -208,7 +330,7 @@ function createBundle(rootPath, projectType, files) {
             nodes.push(toGraphNode(hookKey, 'hook', hook, file.relPath, file, 'react'));
             edges.push(toGraphEdge(file.key, hookKey, 'exports', 'typescript', file));
         }
-        for (const route of file.routes) {
+        for (const route of (0, extractors_1.isTestFile)(file.relPath) ? [] : file.routes) {
             const routeKey = (0, utils_1.toRegistryKey)('route', route);
             const routeLayer = isBackendRouteFile(file) ? 'backend' : 'frontend';
             const styleKey = (0, utils_1.toRegistryKey)('style', file.relPath.replace(/\.[^.]+$/, ''));
@@ -233,7 +355,10 @@ function createBundle(rootPath, projectType, files) {
                     route,
                     path: file.relPath,
                     kind: file.kind,
-                    uiElements: file.uiElements.slice(0, 40),
+                    uiElements: file.uiElements.slice(0, 80),
+                    uiContracts: file.uiElements
+                        .slice(0, 80)
+                        .map((element) => createUiContractForElement(element, file, 'high', styleResolutionContext)),
                     classReferences: file.classReferences.slice(0, 80),
                     tailwindUtilities: file.tailwindUtilities.slice(0, 80),
                     classExpressions: file.classExpressions.slice(0, 80),
@@ -417,31 +542,76 @@ function createBundle(rootPath, projectType, files) {
             nodes.push(toGraphNode(moduleKey, 'module', moduleName, file.relPath, file, (0, extractors_1.moduleExtractorForFile)(file)));
             edges.push(toGraphEdge(file.key, moduleKey, 'exports', (0, extractors_1.moduleExtractorForFile)(file), file));
         }
+        if (hasDatabaseSurface(file)) {
+            addDatabaseSurfaceEntries(entries, usedKeys, nodes, edges, file);
+        }
         for (const model of file.models) {
             const modelKey = (0, utils_1.toRegistryKey)('model', model);
+            const databaseModel = file.databaseModels.find((candidate) => candidate.name === model);
+            const modelRelations = databaseModel?.relations ?? [];
+            const enumRefs = databaseModel?.enumRefs ?? [];
+            const modelDependencies = (0, utils_1.unique)([
+                file.key,
+                ...modelRelations.map((relation) => (0, utils_1.toRegistryKey)('model', relation.toModel)),
+                ...enumRefs.map((enumName) => (0, utils_1.toRegistryKey)('database', `enum.${enumName}`)),
+            ]);
             addEntry(entries, usedKeys, {
                 key: modelKey,
                 group: 'model',
-                summary: `${model} data model in ${file.relPath}.`,
-                tags: ['model', 'schema'],
-                dependencies: [file.key],
+                summary: `${model} ${databaseModel?.kind ?? 'data model'} in ${file.relPath}.`,
+                tags: (0, utils_1.unique)([
+                    'model',
+                    'schema',
+                    'database',
+                    databaseModel?.kind ?? '',
+                    databaseModel?.provider ?? '',
+                    databaseModel?.tableName ?? '',
+                    ...enumRefs,
+                    ...modelRelations.map((relation) => relation.toModel),
+                ]),
+                dependencies: modelDependencies,
                 usedBy: [],
-                confidence: 'high',
+                confidence: databaseModel?.confidence ?? 'high',
                 status: 'inferred',
                 path: file.relPath,
                 value: {
                     name: model,
                     path: file.relPath,
-                    fields: file.modelFields[model] ?? [],
-                    kind: 'model',
+                    fields: file.modelFields[model] ?? databaseModel?.fieldNames ?? [],
+                    fieldDetails: databaseModel?.fields ?? [],
+                    tableName: databaseModel?.tableName,
+                    modelKind: databaseModel?.kind,
+                    provider: databaseModel?.provider,
+                    primaryKey: databaseModel?.primaryKey ?? [],
+                    uniqueFields: databaseModel?.uniqueFields ?? [],
+                    indexes: databaseModel?.indexes ?? [],
+                    relations: modelRelations,
+                    enumRefs,
+                    databaseContract: databaseModel,
+                    kind: databaseModel?.kind === 'table' ? 'database-table' : 'model',
                     sourceHash: file.sourceHash,
-                    source: sourceInfo((0, extractors_1.modelExtractorForFile)(file), 'high', [`model:${model}`], file),
+                    source: sourceInfo(databaseModel ? `database.${databaseModel.provider}` : (0, extractors_1.modelExtractorForFile)(file), databaseModel?.confidence ?? 'high', [
+                        `model:${model}`,
+                        ...(databaseModel?.tableName ? [`table:${databaseModel.tableName}`] : []),
+                    ], file),
                 },
             });
-            nodes.push(toGraphNode(modelKey, 'model', model, file.relPath, file, (0, extractors_1.modelExtractorForFile)(file)));
-            edges.push(toGraphEdge(file.key, modelKey, 'contains', (0, extractors_1.modelExtractorForFile)(file), file));
+            nodes.push(toGraphNode(modelKey, databaseModel?.kind === 'table' ? 'database-table' : 'model', model, file.relPath, file, databaseModel ? `database.${databaseModel.provider}` : (0, extractors_1.modelExtractorForFile)(file), databaseModel
+                ? {
+                    database: {
+                        provider: databaseModel.provider,
+                        tableName: databaseModel.tableName,
+                        fields: databaseModel.fieldNames,
+                        relations: databaseModel.relations.map((relation) => relation.toModel),
+                    },
+                }
+                : undefined));
+            edges.push(toGraphEdge(file.key, modelKey, 'contains', databaseModel ? `database.${databaseModel.provider}` : (0, extractors_1.modelExtractorForFile)(file), file, databaseModel?.confidence ?? 'high'));
+            for (const relation of modelRelations) {
+                edges.push(toGraphEdge(modelKey, (0, utils_1.toRegistryKey)('model', relation.toModel), 'relates_to', databaseModel ? `database.${databaseModel.provider}.relations` : 'database.relations', file, relation.confidence));
+            }
         }
-        if (hasStyleSurface(file)) {
+        if (hasStyleSurface(file) && !(0, extractors_1.isTestFile)(file.relPath)) {
             const styleKey = (0, utils_1.toRegistryKey)('style', file.relPath.replace(/\.[^.]+$/, ''));
             addEntry(entries, usedKeys, {
                 key: styleKey,
@@ -469,6 +639,9 @@ function createBundle(rootPath, projectType, files) {
                     themeTokens: file.themeTokens.slice(0, 240),
                     inlineStyles: file.inlineStyles.slice(0, 100),
                     uiElements: file.uiElements.slice(0, 80),
+                    uiContracts: file.uiElements
+                        .slice(0, 80)
+                        .map((element) => createUiContractForElement(element, file, (0, extractors_1.styleConfidenceForFile)(file), styleResolutionContext)),
                     sourceHash: file.sourceHash,
                     source: sourceInfo((0, extractors_1.styleExtractorForFile)(file), (0, extractors_1.styleConfidenceForFile)(file), ['selectors, classes, tokens, or template UI elements'], file),
                 },
@@ -476,7 +649,7 @@ function createBundle(rootPath, projectType, files) {
             nodes.push(toGraphNode(styleKey, 'style', file.relPath, file.relPath, file, (0, extractors_1.styleExtractorForFile)(file)));
             edges.push(toGraphEdge(file.key, styleKey, 'contains', (0, extractors_1.styleExtractorForFile)(file), file, (0, extractors_1.styleConfidenceForFile)(file)));
         }
-        for (const styleDefinition of file.componentStyleDefinitions) {
+        for (const styleDefinition of (0, extractors_1.isTestFile)(file.relPath) ? [] : file.componentStyleDefinitions) {
             const styleDefinitionKey = (0, utils_1.toRegistryKey)('style', `${file.relPath.replace(/\.[^.]+$/, '')}.${styleDefinition.name}`);
             addEntry(entries, usedKeys, {
                 key: styleDefinitionKey,
@@ -505,6 +678,8 @@ function createBundle(rootPath, projectType, files) {
                     baseClasses: styleDefinition.baseClasses,
                     variants: styleDefinition.variants,
                     defaultVariants: styleDefinition.defaultVariants,
+                    variantRoles: inferStyleDefinitionVariantRoles(styleDefinition),
+                    generationGuidance: createStyleDefinitionGuidance(styleDefinition),
                     classes: styleDefinition.classes,
                     sourceSnippet: styleDefinition.source,
                     sourceHash: file.sourceHash,
@@ -521,15 +696,18 @@ function createBundle(rootPath, projectType, files) {
             edges.push(toGraphEdge(file.key, styleDefinitionKey, 'defines_style', 'component-style-definitions', file, 'high'));
         }
     }
-    addUiPatternRules(entries, usedKeys, nodes, edges, files);
-    addUiCompositionRules(entries, usedKeys, nodes, edges, files);
-    addConnectedPatternRules(entries, usedKeys, nodes, edges, reviewItems, files);
+    addUiPatternRules(entries, usedKeys, nodes, edges, files, styleResolutionContext);
+    addUiCompositionRules(entries, usedKeys, nodes, edges, files, styleResolutionContext);
+    addGlobalUiContractRules(entries, usedKeys, nodes, edges, files);
+    addConnectedPatternRules(entries, usedKeys, nodes, edges, reviewItems, files, styleResolutionContext);
     addRenderEdges(entries, files, edges);
     addImportEdges(entries, files, edges, rootPath);
     addApiCallEdges(entries, files, edges);
     addStyleUsageEdges(entries, files, edges);
+    addDatabaseUsageEdges(entries, files, edges);
     addModelUsageEdges(entries, files, edges);
     addConceptClusters(entries, usedKeys, nodes, edges, reviewItems);
+    addDatabaseReviewItems(entries, reviewItems);
     applyUsedBy(entries, edges);
     return {
         scanId: `${new Date().toISOString()}:${(0, utils_1.shortHash)(rootPath + entries.length)}`,
@@ -576,6 +754,215 @@ function isBackendRouteFile(file) {
         file.apiHandlers.length ||
         file.backendEndpointContracts.length);
 }
+function hasDatabaseSurface(file) {
+    return Boolean(file.databaseModels.length ||
+        file.databaseEnums.length ||
+        file.databaseMigrations.length ||
+        file.databaseAccesses.length);
+}
+function addDatabaseSurfaceEntries(entries, usedKeys, nodes, edges, file) {
+    const extractor = (0, database_1.databaseExtractorForFile)(file.relPath, databaseSurfaceText(file));
+    const confidence = databaseSurfaceConfidence(file);
+    const databaseKey = (0, utils_1.toRegistryKey)('database', file.relPath.replace(/\.[^.]+$/, ''));
+    addEntry(entries, usedKeys, {
+        key: databaseKey,
+        group: 'database',
+        summary: `Database code surface in ${file.relPath}.`,
+        tags: (0, utils_1.unique)([
+            'database',
+            'data',
+            file.language,
+            extractor,
+            ...file.databaseModels.map((model) => model.provider),
+            ...file.databaseModels.map((model) => model.name),
+            ...file.databaseEnums.map((enumValue) => enumValue.name),
+            ...file.databaseAccesses.map((access) => access.operation),
+        ]),
+        dependencies: (0, utils_1.unique)([
+            file.key,
+            ...file.databaseModels.map((model) => (0, utils_1.toRegistryKey)('model', model.name)),
+            ...file.databaseEnums.map((enumValue) => databaseEnumKey(enumValue, file)),
+            ...file.databaseMigrations.map((migration) => (0, utils_1.toRegistryKey)('database', `migration.${migration.name}`)),
+            ...file.databaseAccesses.flatMap(databaseAccessDependencies),
+        ]),
+        usedBy: [],
+        confidence,
+        status: 'inferred',
+        path: file.relPath,
+        value: {
+            path: file.relPath,
+            kind: 'database-surface',
+            models: file.databaseModels,
+            enums: file.databaseEnums,
+            migrations: file.databaseMigrations,
+            accesses: file.databaseAccesses,
+            sourceHash: file.sourceHash,
+            source: sourceInfo(extractor, confidence, ['database models, enums, migrations, or code access patterns'], file),
+        },
+    });
+    nodes.push(toGraphNode(databaseKey, 'database', file.relPath, file.relPath, file, extractor));
+    edges.push(toGraphEdge(file.key, databaseKey, 'contains', 'database.surface', file, confidence));
+    for (const enumValue of file.databaseEnums) {
+        const enumKey = databaseEnumKey(enumValue, file);
+        addEntry(entries, usedKeys, {
+            key: enumKey,
+            group: 'database',
+            summary: `${enumValue.name} database enum with ${enumValue.values.length} values.`,
+            tags: (0, utils_1.unique)(['database', 'enum', enumValue.provider, enumValue.name, ...enumValue.values]),
+            dependencies: [file.key],
+            usedBy: [],
+            confidence: enumValue.confidence,
+            status: 'inferred',
+            path: file.relPath,
+            value: {
+                ...enumValue,
+                kind: 'database-enum',
+                sourceHash: file.sourceHash,
+                source: sourceInfo(`database.${enumValue.provider}`, enumValue.confidence, [`enum:${enumValue.name}`, `values:${enumValue.values.join(',')}`], file),
+            },
+        });
+        nodes.push(toGraphNode(enumKey, 'database-enum', enumValue.name, file.relPath, file, `database.${enumValue.provider}`, {
+            enum: { values: enumValue.values },
+        }));
+        edges.push(toGraphEdge(file.key, enumKey, 'defines_enum', `database.${enumValue.provider}`, file));
+    }
+    for (const migration of file.databaseMigrations) {
+        const migrationKey = (0, utils_1.toRegistryKey)('database', `migration.${migration.name}`);
+        const migrationDependencies = (0, utils_1.unique)([
+            file.key,
+            ...migration.operations
+                .map((operation) => operation.target ?? '')
+                .filter(Boolean)
+                .map((target) => (0, utils_1.toRegistryKey)('model', target)),
+        ]);
+        addEntry(entries, usedKeys, {
+            key: migrationKey,
+            group: 'database',
+            summary: `${migration.name} database migration: ${migration.operations.length} operations.`,
+            tags: (0, utils_1.unique)([
+                'database',
+                'migration',
+                migration.provider,
+                ...(migration.destructive ? ['destructive'] : []),
+                ...(migration.seedLike ? ['seed-like'] : []),
+                ...migration.creates.map((item) => `creates:${item}`),
+                ...migration.alters.map((item) => `alters:${item}`),
+                ...migration.drops.map((item) => `drops:${item}`),
+            ]),
+            dependencies: migrationDependencies,
+            usedBy: [],
+            confidence: migration.confidence,
+            status: migration.destructive ? 'needs_review' : 'inferred',
+            path: file.relPath,
+            value: {
+                ...migration,
+                kind: 'database-migration',
+                sourceHash: file.sourceHash,
+                source: sourceInfo(`database.${migration.provider}.migration`, migration.confidence, [`migration:${migration.name}`, `operations:${migration.operations.length}`], file),
+            },
+        });
+        nodes.push(toGraphNode(migrationKey, 'database-migration', migration.name, file.relPath, file, `database.${migration.provider}.migration`, {
+            migration: {
+                operations: migration.operations.length,
+                destructive: migration.destructive,
+                seedLike: migration.seedLike,
+            },
+        }));
+        edges.push(toGraphEdge(file.key, migrationKey, 'contains', `database.${migration.provider}.migration`, file, migration.confidence));
+        for (const dependency of migrationDependencies.filter((key) => key.startsWith('model.'))) {
+            edges.push(toGraphEdge(migrationKey, dependency, 'changes_schema', `database.${migration.provider}.migration`, file, migration.confidence));
+        }
+    }
+    for (const access of file.databaseAccesses) {
+        const accessKey = (0, utils_1.toRegistryKey)('database', `access.${file.relPath.replace(/\.[^.]+$/, '')}.${access.line}.${access.operation}.${access.model ?? access.table ?? access.receiver ?? 'unknown'}`);
+        const dependencies = (0, utils_1.unique)([file.key, ...databaseAccessDependencies(access)]);
+        addEntry(entries, usedKeys, {
+            key: accessKey,
+            group: 'database',
+            summary: `${(0, utils_1.titleCase)(access.operation)} database access${access.model || access.table ? ` for ${access.model ?? access.table}` : ''} in ${file.relPath}.`,
+            tags: (0, utils_1.unique)([
+                'database',
+                'data-access',
+                access.framework,
+                access.operation,
+                access.model ?? '',
+                access.table ?? '',
+                ...(access.raw ? ['raw-sql'] : []),
+                ...(access.transactional ? ['transaction'] : []),
+                ...access.risk,
+            ]),
+            dependencies,
+            usedBy: [],
+            confidence: access.confidence,
+            status: access.risk.includes('manual-review') ? 'needs_review' : 'inferred',
+            path: file.relPath,
+            value: {
+                ...access,
+                kind: 'database-access',
+                targetKeys: databaseAccessDependencies(access),
+                sourceHash: file.sourceHash,
+                source: sourceInfo(`database.${access.framework}.access`, access.confidence, [`${access.operation}:${access.model ?? access.table ?? access.receiver ?? 'unknown'}`], file),
+            },
+        });
+        nodes.push(toGraphNode(accessKey, 'database-access', `${access.operation}:${access.model ?? access.table ?? 'unknown'}`, file.relPath, file, `database.${access.framework}.access`, {
+            access: {
+                operation: access.operation,
+                model: access.model,
+                table: access.table,
+                risk: access.risk,
+            },
+        }));
+        edges.push(toGraphEdge(file.key, accessKey, 'contains', `database.${access.framework}.access`, file, access.confidence));
+        for (const dependency of dependencies.filter((key) => key.startsWith('model.'))) {
+            const edgeType = databaseAccessEdgeType(access);
+            edges.push(toGraphEdge(accessKey, dependency, edgeType, `database.${access.framework}.access`, file, access.confidence));
+            edges.push(toGraphEdge(file.key, dependency, edgeType, `database.${access.framework}.access`, file, access.confidence));
+        }
+    }
+}
+function databaseSurfaceText(file) {
+    return [
+        file.relPath,
+        file.language,
+        ...file.models,
+        ...file.databaseModels.map((model) => `${model.provider}:${model.name}:${model.tableName ?? ''}`),
+        ...file.databaseEnums.map((enumValue) => `enum:${enumValue.name}`),
+        ...file.databaseMigrations.map((migration) => `migration:${migration.name}`),
+        ...file.databaseAccesses.map((access) => `${access.framework}:${access.operation}:${access.model ?? access.table ?? ''}`),
+    ].join('\n');
+}
+function databaseSurfaceConfidence(file) {
+    if (file.databaseModels.some((model) => model.confidence === 'high') ||
+        file.databaseEnums.length) {
+        return 'high';
+    }
+    if (file.databaseMigrations.length ||
+        file.databaseAccesses.some((access) => access.confidence === 'medium')) {
+        return 'medium';
+    }
+    return 'low';
+}
+function databaseAccessDependencies(access) {
+    return (0, utils_1.unique)([
+        access.model ? (0, utils_1.toRegistryKey)('model', access.model) : '',
+        access.table ? (0, utils_1.toRegistryKey)('model', access.table) : '',
+    ]);
+}
+function databaseAccessEdgeType(access) {
+    if (['create', 'update', 'delete', 'upsert', 'write', 'raw-sql'].includes(access.operation)) {
+        return 'writes';
+    }
+    if (access.operation === 'transaction') {
+        return 'transaction_scope';
+    }
+    return 'reads';
+}
+function databaseEnumKey(enumValue, file) {
+    if (enumValue.provider === 'prisma' && /schema\.prisma$/i.test(file.relPath)) {
+        return (0, utils_1.toRegistryKey)('database', `enum.${enumValue.name}`);
+    }
+    return (0, utils_1.toRegistryKey)('database', `enum.${enumValue.provider}.${enumValue.name}.${(0, utils_1.shortHash)(`${file.relPath}:${enumValue.values.join('|')}`)}`);
+}
 function backendFileContext(file) {
     if (!file.backendEndpointContracts.length &&
         !file.backendOperations.length &&
@@ -594,6 +981,19 @@ function backendFileContext(file) {
         },
     };
 }
+function databaseFileContext(file) {
+    if (!hasDatabaseSurface(file)) {
+        return {};
+    }
+    return {
+        database: {
+            models: file.databaseModels,
+            enums: file.databaseEnums,
+            migrations: file.databaseMigrations,
+            accesses: file.databaseAccesses,
+        },
+    };
+}
 function findEndpointContract(file, handler) {
     const [method, ...pathParts] = handler.split(/\s+/);
     const handlerPath = pathParts.join(' ');
@@ -646,79 +1046,1923 @@ function backendCallDependencies(calls) {
         .filter((call) => ['service', 'repository', 'provider', 'client'].includes(call.kind))
         .map(backendCallKey));
 }
-function addBackendCallEdges(fromKey, calls, file, edges) {
-    for (const call of calls) {
-        const targetKey = backendCallKey(call);
-        edges.push({
-            from: fromKey,
-            to: targetKey,
-            type: call.kind === 'repository' ? 'calls_repository' : 'calls',
-            confidence: call.kind === 'unknown' ? 'low' : 'medium',
-            source: sourceInfo('backend.contract.calls', call.kind === 'unknown' ? 'low' : 'medium', [`${fromKey} calls ${call.receiver}.${call.method}`], file),
-        });
+function addBackendCallEdges(fromKey, calls, file, edges) {
+    for (const call of calls) {
+        const targetKey = backendCallKey(call);
+        edges.push({
+            from: fromKey,
+            to: targetKey,
+            type: call.kind === 'repository' ? 'calls_repository' : 'calls',
+            confidence: call.kind === 'unknown' ? 'low' : 'medium',
+            source: sourceInfo('backend.contract.calls', call.kind === 'unknown' ? 'low' : 'medium', [`${fromKey} calls ${call.receiver}.${call.method}`], file),
+        });
+    }
+}
+function backendCallKey(call) {
+    return (0, utils_1.toRegistryKey)('service', (0, backend_1.backendReceiverToClassName)(call.receiver));
+}
+function uniqueSideEffectsForRecipe(sideEffects) {
+    return (0, utils_1.uniqueBy)(sideEffects, (sideEffect) => `${sideEffect.kind}.${sideEffect.target ?? ''}.${sideEffect.operation ?? ''}.${sideEffect.line}`);
+}
+function sourceInfo(extractor, confidence, evidence, file) {
+    return {
+        extractor,
+        confidence,
+        evidence,
+        path: file.relPath,
+        hash: file.sourceHash,
+    };
+}
+function toGraphNode(key, kind, name, relPath, file, extractor, facets) {
+    return {
+        k: key,
+        kind,
+        name,
+        path: relPath,
+        language: file.language,
+        framework: detectFrameworkForFile(file),
+        ...(facets ? { facets } : {}),
+        source: sourceInfo(extractor, 'high', [`path:${relPath}`], file),
+    };
+}
+function toGraphEdge(from, to, type, extractor, file, confidence = 'high') {
+    return {
+        from,
+        to,
+        type,
+        confidence,
+        source: sourceInfo(extractor, confidence, [`${from} ${type} ${to}`], file),
+    };
+}
+function addRenderEdges(entries, files, edges) {
+    const componentKeysByName = new Map();
+    for (const entry of entries.filter((item) => item.group === 'component')) {
+        const name = typeof entry.value.name === 'string' ? entry.value.name : undefined;
+        if (name) {
+            componentKeysByName.set(name, entry.key);
+        }
+    }
+    for (const file of files) {
+        if (!file.routes.length || !file.jsxElements.length) {
+            continue;
+        }
+        for (const route of file.routes) {
+            const routeKey = (0, utils_1.toRegistryKey)('route', route);
+            for (const jsxElement of file.jsxElements) {
+                const componentKey = componentKeysByName.get(jsxElement);
+                if (componentKey) {
+                    edges.push(toGraphEdge(routeKey, componentKey, 'renders', 'react-jsx', file));
+                }
+            }
+        }
+    }
+}
+function inferStyleDefinitionVariantRoles(styleDefinition) {
+    const roles = {};
+    for (const [groupName, variants] of Object.entries(styleDefinition.variants)) {
+        if (!/^(?:variant|intent|tone|appearance|color)$/i.test(groupName)) {
+            continue;
+        }
+        roles[groupName] = Object.fromEntries(Object.entries(variants).map(([variantName, classes]) => [
+            variantName,
+            inferActionVariantRole(variantName, classes),
+        ]));
+    }
+    return roles;
+}
+function inferActionVariantRole(variantName, classes) {
+    const name = variantName.toLowerCase();
+    const classText = classes.join(' ').toLowerCase();
+    const isGhostLike = /^(?:ghost|link|quiet|plain|unstyled|transparent)$/.test(name) ||
+        (classText.includes('border-transparent') && classText.includes('bg-transparent')) ||
+        classText.includes('rounded-none');
+    const isPrimaryLike = /^(?:default|primary|solid|main)$/.test(name) ||
+        classText.includes('bg-primary') ||
+        classText.includes('text-primary-foreground');
+    const isSecondaryLike = /^(?:secondary|subtle)$/.test(name) ||
+        classText.includes('bg-secondary') ||
+        classText.includes('text-secondary-foreground');
+    const isOutlineLike = /^(?:outline|bordered)$/.test(name) ||
+        (classText.includes('border-border') && classText.includes('bg-transparent'));
+    if (isGhostLike) {
+        return {
+            visualRole: name === 'link' ? 'inline-link' : 'quiet-action',
+            generationRole: 'low-emphasis chrome, navigation, icon, or inline action',
+            ctaSafe: false,
+            emphasis: 'low',
+            avoidFor: ['primary CTA', 'card footer CTA', 'form submit', 'sales/beta conversion'],
+            reason: 'Transparent or link-style variants can look like plain text until hover.',
+        };
+    }
+    if (isPrimaryLike) {
+        return {
+            visualRole: 'primary-action',
+            generationRole: 'main CTA or form submit',
+            ctaSafe: true,
+            emphasis: 'high',
+        };
+    }
+    if (isSecondaryLike) {
+        return {
+            visualRole: 'secondary-action',
+            generationRole: 'secondary CTA or alternate action',
+            ctaSafe: true,
+            emphasis: 'medium',
+        };
+    }
+    if (isOutlineLike) {
+        return {
+            visualRole: 'outlined-action',
+            generationRole: 'secondary CTA when a visible border is desired',
+            ctaSafe: true,
+            emphasis: 'medium',
+        };
+    }
+    return {
+        visualRole: 'custom-action',
+        generationRole: 'use only when the task names this variant or matching source context',
+        ctaSafe: false,
+        emphasis: 'unknown',
+    };
+}
+function createStyleDefinitionGuidance(styleDefinition) {
+    const guidance = [
+        'When generating actions, combine baseClasses with the selected variant and size classes; do not use variant classes alone.',
+    ];
+    const variantRoles = inferStyleDefinitionVariantRoles(styleDefinition);
+    const variantValues = Object.values(variantRoles).flatMap((group) => Object.entries(group));
+    const hasQuietVariant = variantValues.some(([, role]) => role.ctaSafe === false);
+    const hasPrimaryVariant = variantValues.some(([, role]) => role.visualRole === 'primary-action');
+    if (hasPrimaryVariant) {
+        guidance.push('Use primary/default action variants for main conversion CTAs, submit buttons, and card footer actions unless the source pattern says otherwise.');
+    }
+    if (hasQuietVariant) {
+        guidance.push('Do not use ghost/link/quiet variants for primary CTAs; those variants are low-emphasis and may render as text until hover.');
+    }
+    if (Object.keys(styleDefinition.defaultVariants).length) {
+        guidance.push(`Default variants: ${Object.entries(styleDefinition.defaultVariants)
+            .map(([name, value]) => `${name}=${value}`)
+            .join(', ')}.`);
+    }
+    return guidance;
+}
+function summarizeUiElementPatterns(elements, styleContext) {
+    return elements.slice(0, 80).map((element) => {
+        const childStructureContract = element.childSummary?.length
+            ? summarizeElementChildContract(element.childSummary, styleContext)
+            : undefined;
+        const compoundStructure = element.semanticProfile?.isCompound
+            ? summarizeCompoundStructure([element], styleContext)
+            : undefined;
+        return {
+            usage: uiElementPatternUsage(element),
+            kind: element.kind,
+            tag: element.originalTag,
+            ...(element.layoutRole ? { layoutRole: element.layoutRole } : {}),
+            ...(element.parentKind ? { parentKind: element.parentKind } : {}),
+            ...(element.label ? { label: element.label } : {}),
+            line: element.line,
+            uiContract: createUiContractForElement(element, undefined, undefined, styleContext),
+            relationships: createUiRelationships({
+                parentContext: summarizeParentContexts([element])[0],
+                childStructureContract,
+                compoundStructure,
+            }),
+            defaultClasses: element.defaultClasses ?? [],
+            conditionalClasses: element.conditionalClasses ?? [],
+            decorativeAccentClasses: element.decorativeAccentClasses ?? [],
+            classGroups: element.classGroups ?? {},
+            ...(element.layoutSafety ? { layoutSafety: element.layoutSafety } : {}),
+            ...(element.responsiveProfile ? { responsiveProfile: element.responsiveProfile } : {}),
+            ...(element.scaleProfile ? { scaleProfile: element.scaleProfile } : {}),
+            ...(element.semanticProfile ? { semanticProfile: element.semanticProfile } : {}),
+            ...(element.roleSignature ? { roleSignature: element.roleSignature } : {}),
+            ...(childStructureContract ? { childStructure: childStructureContract } : {}),
+            ...(element.variants ? { variants: element.variants } : {}),
+            ...(element.styleHelper ? { styleHelper: element.styleHelper } : {}),
+            ...(element.styleHelperVariants ? { styleHelperVariants: element.styleHelperVariants } : {}),
+        };
+    });
+}
+function uiElementPatternUsage(element) {
+    if (element.layoutRole?.includes('slot')) {
+        return 'slot';
+    }
+    if (!element.parentKind || element.parentKind !== element.kind) {
+        return 'root';
+    }
+    return 'nested';
+}
+function rootUiElementsForKind(elements) {
+    const rootElements = elements.filter((element) => uiElementPatternUsage(element) === 'root');
+    const depthValues = rootElements.map((element) => element.depth ?? 0);
+    const minimumDepth = Math.min(...depthValues);
+    return rootElements.filter((element) => (element.depth ?? 0) === minimumDepth);
+}
+function isLayoutSafetyProfile(value) {
+    return Boolean(value &&
+        typeof value === 'object' &&
+        Array.isArray(value.layoutSafetyClasses));
+}
+function isResponsiveProfile(value) {
+    return Boolean(value &&
+        typeof value === 'object' &&
+        typeof value.breakpoints === 'object' &&
+        !Array.isArray(value.breakpoints));
+}
+function isScaleProfile(value) {
+    return Boolean(value &&
+        typeof value === 'object' &&
+        Array.isArray(value.typographyClasses));
+}
+function isSemanticProfile(value) {
+    return Boolean(value && typeof value === 'object' && Array.isArray(value.roles));
+}
+const tailwindSpacingScale = {
+    '0': '0px',
+    px: '1px',
+    '0.5': '0.125rem',
+    '1': '0.25rem',
+    '1.5': '0.375rem',
+    '2': '0.5rem',
+    '2.5': '0.625rem',
+    '3': '0.75rem',
+    '3.5': '0.875rem',
+    '4': '1rem',
+    '5': '1.25rem',
+    '6': '1.5rem',
+    '7': '1.75rem',
+    '8': '2rem',
+    '9': '2.25rem',
+    '10': '2.5rem',
+    '11': '2.75rem',
+    '12': '3rem',
+    '14': '3.5rem',
+    '16': '4rem',
+    '20': '5rem',
+    '24': '6rem',
+    '28': '7rem',
+    '32': '8rem',
+    '36': '9rem',
+    '40': '10rem',
+    '44': '11rem',
+    '48': '12rem',
+    '52': '13rem',
+    '56': '14rem',
+    '60': '15rem',
+    '64': '16rem',
+    '72': '18rem',
+    '80': '20rem',
+    '96': '24rem',
+};
+const tailwindFontSizeScale = {
+    xs: '0.75rem',
+    sm: '0.875rem',
+    base: '1rem',
+    lg: '1.125rem',
+    xl: '1.25rem',
+    '2xl': '1.5rem',
+    '3xl': '1.875rem',
+    '4xl': '2.25rem',
+    '5xl': '3rem',
+    '6xl': '3.75rem',
+    '7xl': '4.5rem',
+    '8xl': '6rem',
+    '9xl': '8rem',
+};
+const tailwindFontWeightScale = {
+    thin: '100',
+    extralight: '200',
+    light: '300',
+    normal: '400',
+    medium: '500',
+    semibold: '600',
+    bold: '700',
+    extrabold: '800',
+    black: '900',
+};
+const tailwindLineHeightScale = {
+    none: '1',
+    tight: '1.25',
+    snug: '1.375',
+    normal: '1.5',
+    relaxed: '1.625',
+    loose: '2',
+};
+const tailwindTrackingScale = {
+    tighter: '-0.05em',
+    tight: '-0.025em',
+    normal: '0em',
+    wide: '0.025em',
+    wider: '0.05em',
+    widest: '0.1em',
+};
+const tailwindRadiusScale = {
+    none: '0px',
+    sm: '0.125rem',
+    DEFAULT: '0.25rem',
+    md: '0.375rem',
+    lg: '0.5rem',
+    xl: '0.75rem',
+    '2xl': '1rem',
+    '3xl': '1.5rem',
+    full: '9999px',
+};
+const bootstrapSpacingScale = {
+    '0': '0',
+    '1': '0.25rem',
+    '2': '0.5rem',
+    '3': '1rem',
+    '4': '1.5rem',
+    '5': '3rem',
+    auto: 'auto',
+};
+const bootstrapFontSizeScale = {
+    '1': '2.5rem',
+    '2': '2rem',
+    '3': '1.75rem',
+    '4': '1.5rem',
+    '5': '1.25rem',
+    '6': '1rem',
+};
+const bootstrapThemeColors = {
+    primary: 'var(--bs-primary)',
+    secondary: 'var(--bs-secondary)',
+    success: 'var(--bs-success)',
+    danger: 'var(--bs-danger)',
+    warning: 'var(--bs-warning)',
+    info: 'var(--bs-info)',
+    light: 'var(--bs-light)',
+    dark: 'var(--bs-dark)',
+    body: 'var(--bs-body-color)',
+    muted: 'var(--bs-secondary-color)',
+    white: '#fff',
+    black: '#000',
+};
+function createStyleResolutionContext(files) {
+    const classRules = new Map();
+    const cssVariables = new Map();
+    const detectedStyleSystems = detectProjectStyleSystems(files);
+    let ruleOrder = 0;
+    for (const file of files) {
+        for (const variable of file.cssVariableValues) {
+            const values = cssVariables.get(variable.name) ?? [];
+            values.push({
+                value: variable.value,
+                selector: variable.selector,
+                path: file.relPath,
+                line: variable.line,
+            });
+            cssVariables.set(variable.name, values);
+        }
+        for (const rule of file.cssRules) {
+            const classNames = classNamesFromCssSelector(rule.selector);
+            ruleOrder += 1;
+            for (const className of classNames) {
+                const declarations = rule.declarations.map((declaration) => ({
+                    property: declaration.property,
+                    value: normalizeCssDeclarationValue(declaration.value),
+                    resolvedValue: resolveCssValueTokens(declaration.value, cssVariables),
+                    source: 'css-rule',
+                    styleSystem: 'raw-css',
+                    className,
+                    selector: rule.selector,
+                    path: file.relPath,
+                    line: rule.line,
+                    prefixes: cssSelectorStatePrefixes(rule.selector),
+                    media: rule.media ?? cssRuleMediaContext(rule.selector),
+                    specificity: estimateSelectorSpecificity(rule.selector),
+                    ruleOrder,
+                    cascadeRank: estimateSelectorSpecificity(rule.selector) * 10000 +
+                        ruleOrder +
+                        (cssDeclarationImportant(declaration.value) ? 100000000 : 0),
+                    important: cssDeclarationImportant(declaration.value),
+                }));
+                classRules.set(className, [
+                    ...(classRules.get(className) ?? []),
+                    ...declarations,
+                ].slice(-320));
+            }
+        }
+    }
+    return { classRules, cssVariables, detectedStyleSystems };
+}
+function detectProjectStyleSystems(files) {
+    const systems = new Set();
+    const allClasses = (0, utils_1.unique)(files.flatMap((file) => [
+        ...file.classReferences,
+        ...file.tailwindUtilities,
+        ...file.cssClasses,
+        ...file.classExpressions.flatMap((expression) => expression.classes),
+    ]));
+    const dependencyText = files.flatMap((file) => file.dependencies).join(' ').toLowerCase();
+    const importText = files.flatMap((file) => file.imports).join(' ').toLowerCase();
+    const pathText = files.map((file) => file.relPath).join(' ').toLowerCase();
+    if (files.some((file) => file.cssRules.length || file.cssVariableValues.length || file.cssClasses.length)) {
+        systems.add('raw-css');
+    }
+    if (files.some((file) => file.tailwindUtilities.length) ||
+        /tailwind/.test(dependencyText) ||
+        /tailwind/.test(importText) ||
+        /tailwind\.config|tailwind-theme|@tailwind/.test(pathText)) {
+        systems.add('tailwind');
+    }
+    if (allClasses.some(isBootstrapClass) ||
+        /\bbootstrap\b/.test(dependencyText) ||
+        /\bbootstrap\b/.test(importText)) {
+        systems.add('bootstrap');
+    }
+    return Array.from(systems).length ? Array.from(systems) : ['unknown'];
+}
+function classNamesFromCssSelector(selector) {
+    return (0, utils_1.unique)(Array.from(selector.matchAll(/\.((?:\\.|[A-Za-z0-9_-])+)/g))
+        .map((match) => unescapeCssIdentifier(match[1]))
+        .filter(Boolean)).slice(0, 24);
+}
+function unescapeCssIdentifier(value) {
+    return value
+        .replace(/\\:/g, ':')
+        .replace(/\\\//g, '/')
+        .replace(/\\\[/g, '[')
+        .replace(/\\\]/g, ']')
+        .replace(/\\\(/g, '(')
+        .replace(/\\\)/g, ')')
+        .replace(/\\,/g, ',')
+        .replace(/\\\./g, '.')
+        .replace(/\\/g, '');
+}
+function cssSelectorStatePrefixes(selector) {
+    const prefixes = [];
+    if (/:hover\b/.test(selector)) {
+        prefixes.push('hover');
+    }
+    if (/:focus-visible\b/.test(selector)) {
+        prefixes.push('focus-visible');
+    }
+    else if (/:focus\b/.test(selector)) {
+        prefixes.push('focus');
+    }
+    if (/:active\b/.test(selector)) {
+        prefixes.push('active');
+    }
+    if (/:disabled\b|\[disabled\]/.test(selector)) {
+        prefixes.push('disabled');
+    }
+    if (/\[data-[^\]]+\]/.test(selector)) {
+        prefixes.push('data');
+    }
+    return prefixes;
+}
+function cssRuleMediaContext(selector) {
+    const mediaMatch = selector.match(/@media\s*([^{]+)\s+(.+)$/);
+    return mediaMatch?.[1]?.trim();
+}
+function normalizeCssDeclarationValue(value) {
+    return value.replace(/\s*!important\s*$/i, '').trim();
+}
+function cssDeclarationImportant(value) {
+    return /\s!important\s*$/i.test(value);
+}
+function estimateSelectorSpecificity(selector) {
+    const idCount = (selector.match(/#[A-Za-z0-9_-]+/g) ?? []).length;
+    const classCount = (selector.match(/\.[A-Za-z0-9_\\-]+|\[[^\]]+\]|:[A-Za-z-]+/g) ?? []).length;
+    const elementCount = (selector.match(/(^|[\s>+~])([A-Za-z][A-Za-z0-9-]*)/g) ?? []).length;
+    return idCount * 100 + classCount * 10 + elementCount;
+}
+function resolveCssValueTokens(value, cssVariables) {
+    return value.replace(/var\((--[A-Za-z0-9_-]+)(?:,[^)]+)?\)/g, (match, variableName) => {
+        const variableValues = cssVariables?.get(variableName);
+        const latest = variableValues?.[variableValues.length - 1];
+        return latest ? `${match} /* ${latest.value} */` : match;
+    });
+}
+function resolveUiClassDeclarations(classes, styleContext) {
+    const declarations = [];
+    for (const className of classes) {
+        const candidates = (0, utils_1.unique)([className, (0, utils_1.classBase)(className), (0, utils_1.classBase)(className).replace(/^!/, '')]);
+        for (const candidate of candidates) {
+            declarations.push(...(styleContext?.classRules.get(candidate) ?? []).map((declaration) => ({
+                ...declaration,
+                className,
+            })));
+        }
+        declarations.push(...tailwindDeclarationsForClass(className, styleContext));
+        declarations.push(...bootstrapDeclarationsForClass(className, styleContext));
+    }
+    return (0, utils_1.uniqueBy)(declarations, (declaration) => [
+        declaration.className,
+        declaration.property,
+        declaration.value,
+        declaration.source,
+        declaration.selector ?? '',
+        declaration.path ?? '',
+        declaration.line ?? '',
+    ].join(':'))
+        .sort((a, b) => (a.cascadeRank ?? 0) - (b.cascadeRank ?? 0))
+        .slice(0, 360);
+}
+function tailwindDeclarationsForClass(className, styleContext) {
+    const base = (0, utils_1.classBase)(className).replace(/^!/, '');
+    const prefixes = className.split(':').slice(0, -1);
+    const declaration = (property, value) => ({
+        property,
+        value,
+        source: 'tailwind-utility',
+        styleSystem: 'tailwind',
+        className,
+        prefixes,
+        cascadeRank: 10,
+    });
+    const declarations = [];
+    if (base === 'flex')
+        declarations.push(declaration('display', 'flex'));
+    if (base === 'inline-flex')
+        declarations.push(declaration('display', 'inline-flex'));
+    if (base === 'grid')
+        declarations.push(declaration('display', 'grid'));
+    if (base === 'inline-grid')
+        declarations.push(declaration('display', 'inline-grid'));
+    if (base === 'block')
+        declarations.push(declaration('display', 'block'));
+    if (base === 'inline')
+        declarations.push(declaration('display', 'inline'));
+    if (base === 'inline-block')
+        declarations.push(declaration('display', 'inline-block'));
+    if (base === 'hidden')
+        declarations.push(declaration('display', 'none'));
+    if (base === 'contents')
+        declarations.push(declaration('display', 'contents'));
+    if (base === 'table')
+        declarations.push(declaration('display', 'table'));
+    if (base === 'flow-root')
+        declarations.push(declaration('display', 'flow-root'));
+    const alignment = tailwindAlignmentDeclaration(base);
+    if (alignment)
+        declarations.push(declaration(alignment.property, alignment.value));
+    const spacing = tailwindSpacingDeclaration(base);
+    declarations.push(...spacing.map((item) => declaration(item.property, item.value)));
+    const sizing = tailwindSizingDeclaration(base);
+    declarations.push(...sizing.map((item) => declaration(item.property, item.value)));
+    const typography = tailwindTypographyDeclaration(base);
+    declarations.push(...typography.map((item) => declaration(item.property, item.value)));
+    const border = tailwindBorderDeclaration(base, styleContext);
+    declarations.push(...border.map((item) => declaration(item.property, item.value)));
+    const color = tailwindColorDeclaration(base, styleContext);
+    declarations.push(...color.map((item) => declaration(item.property, item.value)));
+    if (base === 'overflow-hidden')
+        declarations.push(declaration('overflow', 'hidden'));
+    if (base === 'overflow-visible')
+        declarations.push(declaration('overflow', 'visible'));
+    if (base === 'overflow-auto')
+        declarations.push(declaration('overflow', 'auto'));
+    if (base === 'overflow-scroll')
+        declarations.push(declaration('overflow', 'scroll'));
+    if (base === 'whitespace-nowrap')
+        declarations.push(declaration('white-space', 'nowrap'));
+    if (base === 'whitespace-normal')
+        declarations.push(declaration('white-space', 'normal'));
+    if (base === 'break-words')
+        declarations.push(declaration('overflow-wrap', 'break-word'));
+    if (base === 'truncate') {
+        declarations.push(declaration('overflow', 'hidden'), declaration('text-overflow', 'ellipsis'), declaration('white-space', 'nowrap'));
+    }
+    if (/^line-clamp-(\d+)$/.test(base)) {
+        const [, lines] = base.match(/^line-clamp-(\d+)$/) ?? [];
+        declarations.push(declaration('overflow', 'hidden'), declaration('display', '-webkit-box'), declaration('-webkit-line-clamp', lines), declaration('-webkit-box-orient', 'vertical'));
+    }
+    if (/^shadow/.test(base)) {
+        declarations.push(declaration('box-shadow', tailwindShadowValue(base)));
+    }
+    if (/^opacity-(\d+)$/.test(base)) {
+        const [, value] = base.match(/^opacity-(\d+)$/) ?? [];
+        declarations.push(declaration('opacity', String(Number(value) / 100)));
+    }
+    if (/^grid-cols-(\d+)$/.test(base)) {
+        const [, value] = base.match(/^grid-cols-(\d+)$/) ?? [];
+        declarations.push(declaration('grid-template-columns', `repeat(${value}, minmax(0, 1fr))`));
+    }
+    if (/^grid-cols-\[([^\]]+)\]$/.test(base)) {
+        declarations.push(declaration('grid-template-columns', arbitraryValue(base).replace(/_/g, ' ')));
+    }
+    if (/^grid-rows-(\d+)$/.test(base)) {
+        const [, value] = base.match(/^grid-rows-(\d+)$/) ?? [];
+        declarations.push(declaration('grid-template-rows', `repeat(${value}, minmax(0, 1fr))`));
+    }
+    if (/^grid-rows-\[([^\]]+)\]$/.test(base)) {
+        declarations.push(declaration('grid-template-rows', arbitraryValue(base).replace(/_/g, ' ')));
+    }
+    if (base === 'auto-rows-fr') {
+        declarations.push(declaration('grid-auto-rows', 'minmax(0, 1fr)'));
+    }
+    if (/^auto-rows-\[([^\]]+)\]$/.test(base)) {
+        declarations.push(declaration('grid-auto-rows', arbitraryValue(base).replace(/_/g, ' ')));
+    }
+    if (base === 'flex-row')
+        declarations.push(declaration('flex-direction', 'row'));
+    if (base === 'flex-col')
+        declarations.push(declaration('flex-direction', 'column'));
+    if (base === 'flex-wrap')
+        declarations.push(declaration('flex-wrap', 'wrap'));
+    if (base === 'flex-nowrap')
+        declarations.push(declaration('flex-wrap', 'nowrap'));
+    if (base === 'object-cover')
+        declarations.push(declaration('object-fit', 'cover'));
+    if (base === 'object-contain')
+        declarations.push(declaration('object-fit', 'contain'));
+    if (base === 'object-fill')
+        declarations.push(declaration('object-fit', 'fill'));
+    if (base === 'object-center')
+        declarations.push(declaration('object-position', 'center'));
+    if (/^aspect-\[([^\]]+)\]$/.test(base)) {
+        declarations.push(declaration('aspect-ratio', arbitraryValue(base).replace(/_/g, ' ')));
+    }
+    if (/^col-span-(\d+)$/.test(base)) {
+        const [, value] = base.match(/^col-span-(\d+)$/) ?? [];
+        declarations.push(declaration('grid-column', `span ${value} / span ${value}`));
+    }
+    if (/^row-span-(\d+)$/.test(base)) {
+        const [, value] = base.match(/^row-span-(\d+)$/) ?? [];
+        declarations.push(declaration('grid-row', `span ${value} / span ${value}`));
+    }
+    if (/^(?:relative|absolute|fixed|sticky|static)$/.test(base)) {
+        declarations.push(declaration('position', base));
+    }
+    if (/^(?:inset|top|right|bottom|left)-(.+)$/.test(base)) {
+        const [, property, token] = base.match(/^(inset|top|right|bottom|left)-(.+)$/) ?? [];
+        const value = tailwindScaleValue(token);
+        if (value)
+            declarations.push(declaration(property, value));
+    }
+    if (/^z-\[([^\]]+)\]$/.test(base)) {
+        declarations.push(declaration('z-index', arbitraryValue(base)));
+    }
+    if (/^z-(\d+)$/.test(base)) {
+        const [, value] = base.match(/^z-(\d+)$/) ?? [];
+        declarations.push(declaration('z-index', value));
+    }
+    return declarations;
+}
+function tailwindAlignmentDeclaration(base) {
+    const alignItems = {
+        'items-start': 'flex-start',
+        'items-end': 'flex-end',
+        'items-center': 'center',
+        'items-baseline': 'baseline',
+        'items-stretch': 'stretch',
+    };
+    const justifyContent = {
+        'justify-start': 'flex-start',
+        'justify-end': 'flex-end',
+        'justify-center': 'center',
+        'justify-between': 'space-between',
+        'justify-around': 'space-around',
+        'justify-evenly': 'space-evenly',
+    };
+    if (alignItems[base])
+        return { property: 'align-items', value: alignItems[base] };
+    if (justifyContent[base])
+        return { property: 'justify-content', value: justifyContent[base] };
+    return undefined;
+}
+function tailwindSpacingDeclaration(base) {
+    const spacingMatch = base.match(/^(p|px|py|pt|pr|pb|pl|m|mx|my|mt|mr|mb|ml|gap|gap-x|gap-y)-(.+)$/);
+    if (!spacingMatch) {
+        return [];
+    }
+    const [, prefix, token] = spacingMatch;
+    const value = token === 'auto' ? 'auto' : tailwindScaleValue(token);
+    if (!value) {
+        return [];
+    }
+    const properties = {
+        p: ['padding'],
+        px: ['padding-left', 'padding-right'],
+        py: ['padding-top', 'padding-bottom'],
+        pt: ['padding-top'],
+        pr: ['padding-right'],
+        pb: ['padding-bottom'],
+        pl: ['padding-left'],
+        m: ['margin'],
+        mx: ['margin-left', 'margin-right'],
+        my: ['margin-top', 'margin-bottom'],
+        mt: ['margin-top'],
+        mr: ['margin-right'],
+        mb: ['margin-bottom'],
+        ml: ['margin-left'],
+        gap: ['gap'],
+        'gap-x': ['column-gap'],
+        'gap-y': ['row-gap'],
+    };
+    return (properties[prefix] ?? []).map((property) => ({ property, value }));
+}
+function tailwindSizingDeclaration(base) {
+    if (base === 'min-w-0')
+        return [{ property: 'min-width', value: '0px' }];
+    if (base === 'min-h-0')
+        return [{ property: 'min-height', value: '0px' }];
+    if (base === 'w-px')
+        return [{ property: 'width', value: '1px' }];
+    if (base === 'h-px')
+        return [{ property: 'height', value: '1px' }];
+    if (base === 'w-full')
+        return [{ property: 'width', value: '100%' }];
+    if (base === 'h-full')
+        return [{ property: 'height', value: '100%' }];
+    if (base === 'max-w-none')
+        return [{ property: 'max-width', value: 'none' }];
+    if (base === 'shrink-0')
+        return [{ property: 'flex-shrink', value: '0' }];
+    if (base === 'shrink')
+        return [{ property: 'flex-shrink', value: '1' }];
+    if (base === 'grow')
+        return [{ property: 'flex-grow', value: '1' }];
+    if (base === 'grow-0')
+        return [{ property: 'flex-grow', value: '0' }];
+    const sizeMatch = base.match(/^(size|w|h|min-w|min-h|max-w|max-h)-(.+)$/);
+    if (!sizeMatch) {
+        return [];
+    }
+    const [, prefix, token] = sizeMatch;
+    const value = tailwindScaleValue(token) ?? tailwindNamedSizeValue(token);
+    if (!value) {
+        return [];
+    }
+    const properties = {
+        size: ['width', 'height'],
+        w: ['width'],
+        h: ['height'],
+        'min-w': ['min-width'],
+        'min-h': ['min-height'],
+        'max-w': ['max-width'],
+        'max-h': ['max-height'],
+    };
+    return (properties[prefix] ?? []).map((property) => ({ property, value }));
+}
+function tailwindTypographyDeclaration(base) {
+    const declarations = [];
+    const textMatch = base.match(/^text-(.+)$/);
+    if (textMatch) {
+        const token = textMatch[1];
+        const arbitrary = arbitraryTokenValue(token);
+        if (arbitrary && looksLikeCssLength(arbitrary)) {
+            declarations.push({ property: 'font-size', value: arbitrary });
+        }
+        else if (tailwindFontSizeScale[token]) {
+            declarations.push({ property: 'font-size', value: tailwindFontSizeScale[token] });
+        }
+    }
+    const weightMatch = base.match(/^font-(thin|extralight|light|normal|medium|semibold|bold|extrabold|black)$/);
+    if (weightMatch)
+        declarations.push({ property: 'font-weight', value: tailwindFontWeightScale[weightMatch[1]] });
+    const leadingMatch = base.match(/^leading-(.+)$/);
+    if (leadingMatch) {
+        const token = leadingMatch[1];
+        const arbitrary = arbitraryTokenValue(token);
+        const value = arbitrary ?? tailwindLineHeightScale[token] ?? tailwindScaleValue(token);
+        if (value)
+            declarations.push({ property: 'line-height', value });
+    }
+    const trackingMatch = base.match(/^tracking-(.+)$/);
+    if (trackingMatch) {
+        const token = trackingMatch[1];
+        const arbitrary = arbitraryTokenValue(token);
+        const value = arbitrary ?? tailwindTrackingScale[token];
+        if (value)
+            declarations.push({ property: 'letter-spacing', value });
+    }
+    if (base === 'uppercase')
+        declarations.push({ property: 'text-transform', value: 'uppercase' });
+    if (base === 'lowercase')
+        declarations.push({ property: 'text-transform', value: 'lowercase' });
+    if (base === 'capitalize')
+        declarations.push({ property: 'text-transform', value: 'capitalize' });
+    if (base === 'normal-case')
+        declarations.push({ property: 'text-transform', value: 'none' });
+    if (base === 'text-left')
+        declarations.push({ property: 'text-align', value: 'left' });
+    if (base === 'text-center')
+        declarations.push({ property: 'text-align', value: 'center' });
+    if (base === 'text-right')
+        declarations.push({ property: 'text-align', value: 'right' });
+    return declarations;
+}
+function tailwindBorderDeclaration(base, styleContext) {
+    if (base === 'border')
+        return [{ property: 'border-width', value: '1px' }];
+    if (/^border-(\d+)$/.test(base)) {
+        const [, value] = base.match(/^border-(\d+)$/) ?? [];
+        return [{ property: 'border-width', value: `${value}px` }];
+    }
+    const roundedMatch = base.match(/^rounded(?:-(.+))?$/);
+    if (roundedMatch) {
+        const token = roundedMatch[1] ?? 'DEFAULT';
+        const arbitrary = arbitraryTokenValue(token);
+        const value = arbitrary ?? tailwindRadiusScale[token] ?? cssTokenValue('radius', styleContext);
+        return value ? [{ property: 'border-radius', value }] : [];
+    }
+    if (base.startsWith('border-') && !/^border-(?:t|r|b|l|x|y)$/.test(base)) {
+        return [{ property: 'border-color', value: tailwindColorValue(base.slice('border-'.length), styleContext) }];
+    }
+    return [];
+}
+function tailwindColorDeclaration(base, styleContext) {
+    const bgMatch = base.match(/^bg-(.+)$/);
+    if (bgMatch) {
+        return [{ property: 'background-color', value: tailwindColorValue(bgMatch[1], styleContext) }];
+    }
+    const textMatch = base.match(/^text-(.+)$/);
+    if (textMatch && !tailwindFontSizeScale[textMatch[1]] && !looksLikeCssLength(arbitraryTokenValue(textMatch[1]) ?? '')) {
+        return [{ property: 'color', value: tailwindColorValue(textMatch[1], styleContext) }];
+    }
+    const fillMatch = base.match(/^fill-(.+)$/);
+    if (fillMatch)
+        return [{ property: 'fill', value: tailwindColorValue(fillMatch[1], styleContext) }];
+    const strokeMatch = base.match(/^stroke-(.+)$/);
+    if (strokeMatch)
+        return [{ property: 'stroke', value: tailwindColorValue(strokeMatch[1], styleContext) }];
+    return [];
+}
+function tailwindColorValue(token, styleContext) {
+    const arbitrary = arbitraryTokenValue(token);
+    if (arbitrary) {
+        return resolveCssValueTokens(arbitrary.replace(/_/g, ' '), styleContext?.cssVariables);
+    }
+    const [name, opacity] = token.split('/');
+    const cssVariable = cssTokenValue(name, styleContext);
+    const baseValue = cssVariable ?? colorKeywordValue(name) ?? `token(${name})`;
+    return opacity ? `${baseValue} / ${opacityToPercent(opacity)}` : baseValue;
+}
+function cssTokenValue(token, styleContext) {
+    const candidates = (0, utils_1.unique)([`--${token}`, `--color-${token}`, `--${token.replace(/\//g, '-')}`]);
+    const match = candidates.find((candidate) => styleContext?.cssVariables.has(candidate));
+    return match ? `var(${match})` : undefined;
+}
+function colorKeywordValue(token) {
+    const colors = {
+        transparent: 'transparent',
+        current: 'currentColor',
+        black: '#000000',
+        white: '#ffffff',
+    };
+    return colors[token];
+}
+function opacityToPercent(value) {
+    const arbitrary = arbitraryTokenValue(value);
+    if (arbitrary) {
+        const numericArbitrary = Number(arbitrary);
+        if (Number.isFinite(numericArbitrary)) {
+            return `${numericArbitrary * 100}%`;
+        }
+        return arbitrary;
+    }
+    const numeric = Number(value);
+    if (Number.isFinite(numeric)) {
+        return `${numeric}%`;
+    }
+    return value;
+}
+function tailwindScaleValue(token) {
+    const arbitrary = arbitraryTokenValue(token);
+    if (arbitrary) {
+        return arbitrary.replace(/_/g, ' ');
+    }
+    const negative = token.startsWith('-');
+    const lookup = negative ? token.slice(1) : token;
+    const value = tailwindSpacingScale[lookup];
+    return value ? `${negative ? '-' : ''}${value}` : undefined;
+}
+function tailwindNamedSizeValue(token) {
+    const values = {
+        auto: 'auto',
+        full: '100%',
+        screen: '100vw',
+        svw: '100svw',
+        lvw: '100lvw',
+        dvw: '100dvw',
+        min: 'min-content',
+        max: 'max-content',
+        fit: 'fit-content',
+        prose: '65ch',
+        xs: '20rem',
+        sm: '24rem',
+        md: '28rem',
+        lg: '32rem',
+        xl: '36rem',
+        '2xl': '42rem',
+        '3xl': '48rem',
+        '4xl': '56rem',
+        '5xl': '64rem',
+        '6xl': '72rem',
+        '7xl': '80rem',
+    };
+    return values[token];
+}
+function arbitraryTokenValue(token) {
+    const match = token.match(/^\[(.+)\]$/);
+    return match?.[1];
+}
+function arbitraryValue(base) {
+    return base.match(/\[(.+)\]/)?.[1] ?? '';
+}
+function looksLikeCssLength(value) {
+    return /^-?(?:\d|\.)/.test(value) || /^var\(--/.test(value) || /^clamp\(/.test(value);
+}
+function tailwindShadowValue(base) {
+    const arbitrary = arbitraryValue(base);
+    if (arbitrary) {
+        return arbitrary.replace(/_/g, ' ');
+    }
+    if (base === 'shadow-none') {
+        return 'none';
+    }
+    return `tailwind(${base})`;
+}
+function bootstrapDeclarationsForClass(className, styleContext) {
+    const base = (0, utils_1.classBase)(className).replace(/^!/, '');
+    if (!isBootstrapClass(base)) {
+        return [];
+    }
+    const prefixes = bootstrapResponsivePrefixes(base);
+    const normalized = stripBootstrapResponsiveInfix(base);
+    const declaration = (property, value) => ({
+        property,
+        value: resolveCssValueTokens(value, styleContext?.cssVariables),
+        source: 'bootstrap-utility',
+        styleSystem: 'bootstrap',
+        className,
+        prefixes,
+        cascadeRank: 20,
+    });
+    const declarations = [];
+    declarations.push(...bootstrapComponentDeclarations(normalized).map((item) => declaration(item.property, item.value)));
+    declarations.push(...bootstrapSpacingDeclarations(normalized).map((item) => declaration(item.property, item.value)));
+    declarations.push(...bootstrapDisplayDeclarations(normalized).map((item) => declaration(item.property, item.value)));
+    declarations.push(...bootstrapFlexDeclarations(normalized).map((item) => declaration(item.property, item.value)));
+    declarations.push(...bootstrapSizingDeclarations(normalized).map((item) => declaration(item.property, item.value)));
+    declarations.push(...bootstrapTypographyDeclarations(normalized).map((item) => declaration(item.property, item.value)));
+    declarations.push(...bootstrapColorDeclarations(normalized).map((item) => declaration(item.property, item.value)));
+    declarations.push(...bootstrapBorderDeclarations(normalized).map((item) => declaration(item.property, item.value)));
+    declarations.push(...bootstrapGridDeclarations(normalized).map((item) => declaration(item.property, item.value)));
+    return declarations;
+}
+function isBootstrapClass(className) {
+    const base = stripBootstrapResponsiveInfix((0, utils_1.classBase)(className));
+    return /^(?:container|container-fluid|row|col|col-\d+|card|card-(?:body|title|text|header|footer)|btn|btn-(?:primary|secondary|success|danger|warning|info|light|dark|link|outline-primary|outline-secondary|outline-success|outline-danger|outline-warning|outline-info|outline-light|outline-dark)|badge|rounded|rounded-\d|rounded-pill|rounded-circle|border|border-\d|border-(?:0|top|end|bottom|start|primary|secondary|success|danger|warning|info|light|dark|white)|bg-|text-|fw-|fs-|lh-|display-|lead|small|d-|flex-|justify-content-|align-items-|align-self-|order-|m[stebxy]?-|p[stebxy]?-|gap-|w-|h-|mw-|mh-|min-vh-|min-vw-|vw-|vh-|form-|input-group|navbar|nav|nav-|list-group|modal|alert|shadow|overflow-|position-|top-|bottom-|start-|end-|translate-middle|visually-hidden)/.test(base);
+}
+function bootstrapResponsivePrefixes(className) {
+    const match = className.match(/^(?:d|col|offset|order|m[stebxy]?|p[stebxy]?|gap|text|float|flex|justify-content|align-items|align-self)-((?:sm|md|lg|xl|xxl))-/);
+    return match ? [match[1]] : [];
+}
+function stripBootstrapResponsiveInfix(className) {
+    return className.replace(/^(d|col|offset|order|m[stebxy]?|p[stebxy]?|gap|text|float|flex|justify-content|align-items|align-self)-(sm|md|lg|xl|xxl)-/, '$1-');
+}
+function bootstrapComponentDeclarations(base) {
+    const declarations = [];
+    if (base === 'container' || base === 'container-fluid') {
+        declarations.push({ property: 'width', value: '100%' }, { property: 'padding-right', value: 'calc(var(--bs-gutter-x, 1.5rem) * 0.5)' }, { property: 'padding-left', value: 'calc(var(--bs-gutter-x, 1.5rem) * 0.5)' }, { property: 'margin-right', value: 'auto' }, { property: 'margin-left', value: 'auto' });
+    }
+    if (base === 'row') {
+        declarations.push({ property: 'display', value: 'flex' }, { property: 'flex-wrap', value: 'wrap' }, { property: 'margin-top', value: 'calc(-1 * var(--bs-gutter-y, 0))' }, { property: 'margin-right', value: 'calc(-0.5 * var(--bs-gutter-x, 1.5rem))' }, { property: 'margin-left', value: 'calc(-0.5 * var(--bs-gutter-x, 1.5rem))' });
+    }
+    if (base === 'card') {
+        declarations.push({ property: 'position', value: 'relative' }, { property: 'display', value: 'flex' }, { property: 'flex-direction', value: 'column' }, { property: 'min-width', value: '0' }, { property: 'color', value: 'var(--bs-body-color)' }, { property: 'background-color', value: 'var(--bs-card-bg)' }, { property: 'border', value: 'var(--bs-card-border-width) solid var(--bs-card-border-color)' }, { property: 'border-radius', value: 'var(--bs-card-border-radius)' });
+    }
+    if (base === 'card-body') {
+        declarations.push({ property: 'flex', value: '1 1 auto' }, { property: 'padding', value: 'var(--bs-card-spacer-y) var(--bs-card-spacer-x)' }, { property: 'color', value: 'var(--bs-card-color)' });
+    }
+    if (base === 'btn') {
+        declarations.push({ property: 'display', value: 'inline-block' }, { property: 'padding', value: 'var(--bs-btn-padding-y) var(--bs-btn-padding-x)' }, { property: 'font-size', value: 'var(--bs-btn-font-size)' }, { property: 'font-weight', value: 'var(--bs-btn-font-weight)' }, { property: 'line-height', value: 'var(--bs-btn-line-height)' }, { property: 'text-align', value: 'center' }, { property: 'text-decoration', value: 'none' }, { property: 'vertical-align', value: 'middle' }, { property: 'cursor', value: 'pointer' }, { property: 'border', value: 'var(--bs-btn-border-width) solid var(--bs-btn-border-color)' }, { property: 'border-radius', value: 'var(--bs-btn-border-radius)' });
+    }
+    if (base.startsWith('btn-') && base !== 'btn-link') {
+        const tone = base.replace(/^btn-outline-/, '').replace(/^btn-/, '');
+        const outline = base.startsWith('btn-outline-');
+        declarations.push({ property: 'color', value: outline ? `var(--bs-${tone})` : `var(--bs-btn-color)` }, {
+            property: 'background-color',
+            value: outline ? 'transparent' : `var(--bs-${tone})`,
+        }, { property: 'border-color', value: `var(--bs-${tone})` });
+    }
+    if (base === 'btn-link') {
+        declarations.push({ property: 'font-weight', value: '400' }, { property: 'color', value: 'var(--bs-link-color)' }, { property: 'text-decoration', value: 'underline' }, { property: 'background-color', value: 'transparent' }, { property: 'border-color', value: 'transparent' });
+    }
+    if (base === 'badge') {
+        declarations.push({ property: 'display', value: 'inline-block' }, { property: 'padding', value: '0.35em 0.65em' }, { property: 'font-size', value: '0.75em' }, { property: 'font-weight', value: '700' }, { property: 'line-height', value: '1' }, { property: 'color', value: '#fff' }, { property: 'text-align', value: 'center' }, { property: 'white-space', value: 'nowrap' }, { property: 'vertical-align', value: 'baseline' }, { property: 'border-radius', value: 'var(--bs-border-radius)' });
+    }
+    if (base === 'form-control' || base === 'form-select') {
+        declarations.push({ property: 'display', value: 'block' }, { property: 'width', value: '100%' }, { property: 'padding', value: '0.375rem 0.75rem' }, { property: 'font-size', value: '1rem' }, { property: 'font-weight', value: '400' }, { property: 'line-height', value: '1.5' }, { property: 'color', value: 'var(--bs-body-color)' }, { property: 'background-color', value: 'var(--bs-body-bg)' }, { property: 'border', value: 'var(--bs-border-width) solid var(--bs-border-color)' }, { property: 'border-radius', value: 'var(--bs-border-radius)' });
+    }
+    if (base === 'form-label') {
+        declarations.push({ property: 'margin-bottom', value: '0.5rem' }, { property: 'display', value: 'inline-block' });
+    }
+    if (base === 'navbar') {
+        declarations.push({ property: 'position', value: 'relative' }, { property: 'display', value: 'flex' }, { property: 'flex-wrap', value: 'wrap' }, { property: 'align-items', value: 'center' }, { property: 'justify-content', value: 'space-between' }, { property: 'padding', value: 'var(--bs-navbar-padding-y) var(--bs-navbar-padding-x)' });
+    }
+    if (base === 'nav') {
+        declarations.push({ property: 'display', value: 'flex' }, { property: 'flex-wrap', value: 'wrap' }, { property: 'padding-left', value: '0' }, { property: 'margin-bottom', value: '0' }, { property: 'list-style', value: 'none' });
+    }
+    if (base === 'nav-link') {
+        declarations.push({ property: 'display', value: 'block' }, { property: 'padding', value: 'var(--bs-nav-link-padding-y) var(--bs-nav-link-padding-x)' }, { property: 'font-size', value: 'var(--bs-nav-link-font-size)' }, { property: 'font-weight', value: 'var(--bs-nav-link-font-weight)' }, { property: 'color', value: 'var(--bs-nav-link-color)' }, { property: 'text-decoration', value: 'none' });
+    }
+    if (base === 'alert') {
+        declarations.push({ property: 'position', value: 'relative' }, { property: 'padding', value: 'var(--bs-alert-padding-y) var(--bs-alert-padding-x)' }, { property: 'margin-bottom', value: '1rem' }, { property: 'border', value: 'var(--bs-alert-border) solid var(--bs-alert-border-color)' }, { property: 'border-radius', value: 'var(--bs-alert-border-radius)' });
+    }
+    return declarations;
+}
+function bootstrapSpacingDeclarations(base) {
+    const match = base.match(/^(m|p)([stebxy]?)-([0-5]|auto)$/);
+    if (!match) {
+        return [];
+    }
+    const [, kind, direction, token] = match;
+    const value = bootstrapSpacingScale[token];
+    const propertyRoot = kind === 'm' ? 'margin' : 'padding';
+    const directionMap = {
+        '': [propertyRoot],
+        t: [`${propertyRoot}-top`],
+        e: [`${propertyRoot}-right`],
+        b: [`${propertyRoot}-bottom`],
+        s: [`${propertyRoot}-left`],
+        x: [`${propertyRoot}-left`, `${propertyRoot}-right`],
+        y: [`${propertyRoot}-top`, `${propertyRoot}-bottom`],
+    };
+    return (directionMap[direction] ?? []).map((property) => ({ property, value }));
+}
+function bootstrapDisplayDeclarations(base) {
+    const match = base.match(/^d-(none|inline|inline-block|block|grid|inline-grid|table|table-row|table-cell|flex|inline-flex)$/);
+    return match ? [{ property: 'display', value: match[1] }] : [];
+}
+function bootstrapFlexDeclarations(base) {
+    const declarations = [];
+    const justifyMap = {
+        start: 'flex-start',
+        end: 'flex-end',
+        center: 'center',
+        between: 'space-between',
+        around: 'space-around',
+        evenly: 'space-evenly',
+    };
+    const alignMap = {
+        start: 'flex-start',
+        end: 'flex-end',
+        center: 'center',
+        baseline: 'baseline',
+        stretch: 'stretch',
+    };
+    if (base === 'flex-row')
+        declarations.push({ property: 'flex-direction', value: 'row' });
+    if (base === 'flex-column')
+        declarations.push({ property: 'flex-direction', value: 'column' });
+    if (base === 'flex-wrap')
+        declarations.push({ property: 'flex-wrap', value: 'wrap' });
+    if (base === 'flex-nowrap')
+        declarations.push({ property: 'flex-wrap', value: 'nowrap' });
+    const justify = base.match(/^justify-content-(start|end|center|between|around|evenly)$/);
+    if (justify)
+        declarations.push({ property: 'justify-content', value: justifyMap[justify[1]] });
+    const alignItems = base.match(/^align-items-(start|end|center|baseline|stretch)$/);
+    if (alignItems)
+        declarations.push({ property: 'align-items', value: alignMap[alignItems[1]] });
+    const alignSelf = base.match(/^align-self-(start|end|center|baseline|stretch)$/);
+    if (alignSelf)
+        declarations.push({ property: 'align-self', value: alignMap[alignSelf[1]] });
+    return declarations;
+}
+function bootstrapSizingDeclarations(base) {
+    const percentMatch = base.match(/^(w|h|mw|mh)-(\d+)$/);
+    if (percentMatch) {
+        const [, prefix, amount] = percentMatch;
+        const propertyMap = {
+            w: 'width',
+            h: 'height',
+            mw: 'max-width',
+            mh: 'max-height',
+        };
+        return [{ property: propertyMap[prefix], value: `${amount}%` }];
+    }
+    if (base === 'min-vh-100')
+        return [{ property: 'min-height', value: '100vh' }];
+    if (base === 'min-vw-100')
+        return [{ property: 'min-width', value: '100vw' }];
+    if (base === 'vh-100')
+        return [{ property: 'height', value: '100vh' }];
+    if (base === 'vw-100')
+        return [{ property: 'width', value: '100vw' }];
+    return [];
+}
+function bootstrapTypographyDeclarations(base) {
+    const declarations = [];
+    const fsMatch = base.match(/^fs-([1-6])$/);
+    if (fsMatch)
+        declarations.push({ property: 'font-size', value: bootstrapFontSizeScale[fsMatch[1]] });
+    const fwMap = {
+        lighter: 'lighter',
+        light: '300',
+        normal: '400',
+        semibold: '600',
+        bold: '700',
+        bolder: 'bolder',
+    };
+    const fwMatch = base.match(/^fw-(lighter|light|normal|semibold|bold|bolder)$/);
+    if (fwMatch)
+        declarations.push({ property: 'font-weight', value: fwMap[fwMatch[1]] });
+    const textAlign = base.match(/^text-(start|end|center)$/);
+    if (textAlign) {
+        declarations.push({ property: 'text-align', value: textAlign[1] === 'start' ? 'left' : textAlign[1] === 'end' ? 'right' : 'center' });
+    }
+    if (base === 'text-uppercase')
+        declarations.push({ property: 'text-transform', value: 'uppercase' });
+    if (base === 'text-lowercase')
+        declarations.push({ property: 'text-transform', value: 'lowercase' });
+    if (base === 'text-capitalize')
+        declarations.push({ property: 'text-transform', value: 'capitalize' });
+    if (base === 'lead') {
+        declarations.push({ property: 'font-size', value: '1.25rem' }, { property: 'font-weight', value: '300' });
+    }
+    if (base === 'small')
+        declarations.push({ property: 'font-size', value: '0.875em' });
+    const lhMap = { '1': '1', sm: '1.25', base: '1.5', lg: '2' };
+    const lhMatch = base.match(/^lh-(1|sm|base|lg)$/);
+    if (lhMatch)
+        declarations.push({ property: 'line-height', value: lhMap[lhMatch[1]] });
+    return declarations;
+}
+function bootstrapColorDeclarations(base) {
+    const declarations = [];
+    const bgMatch = base.match(/^bg-(primary|secondary|success|danger|warning|info|light|dark|body|white|transparent)$/);
+    if (bgMatch) {
+        declarations.push({
+            property: 'background-color',
+            value: bgMatch[1] === 'transparent' ? 'transparent' : bootstrapThemeColors[bgMatch[1]],
+        });
+    }
+    const textMatch = base.match(/^text-(primary|secondary|success|danger|warning|info|light|dark|body|muted|white|black)$/);
+    if (textMatch)
+        declarations.push({ property: 'color', value: bootstrapThemeColors[textMatch[1]] });
+    return declarations;
+}
+function bootstrapBorderDeclarations(base) {
+    const declarations = [];
+    if (base === 'border')
+        declarations.push({ property: 'border', value: 'var(--bs-border-width) var(--bs-border-style) var(--bs-border-color)' });
+    if (base === 'border-0')
+        declarations.push({ property: 'border', value: '0' });
+    if (/^border-[1-5]$/.test(base)) {
+        declarations.push({ property: 'border-width', value: `${base.replace('border-', '')}px` });
+    }
+    const borderColor = base.match(/^border-(primary|secondary|success|danger|warning|info|light|dark|white)$/);
+    if (borderColor)
+        declarations.push({ property: 'border-color', value: bootstrapThemeColors[borderColor[1]] });
+    if (base === 'rounded')
+        declarations.push({ property: 'border-radius', value: 'var(--bs-border-radius)' });
+    if (base === 'rounded-0')
+        declarations.push({ property: 'border-radius', value: '0' });
+    if (base === 'rounded-1')
+        declarations.push({ property: 'border-radius', value: 'var(--bs-border-radius-sm)' });
+    if (base === 'rounded-2')
+        declarations.push({ property: 'border-radius', value: 'var(--bs-border-radius)' });
+    if (base === 'rounded-3')
+        declarations.push({ property: 'border-radius', value: 'var(--bs-border-radius-lg)' });
+    if (base === 'rounded-4')
+        declarations.push({ property: 'border-radius', value: 'var(--bs-border-radius-xl)' });
+    if (base === 'rounded-5')
+        declarations.push({ property: 'border-radius', value: 'var(--bs-border-radius-xxl)' });
+    if (base === 'rounded-pill')
+        declarations.push({ property: 'border-radius', value: 'var(--bs-border-radius-pill)' });
+    if (base === 'rounded-circle')
+        declarations.push({ property: 'border-radius', value: '50%' });
+    if (base === 'shadow')
+        declarations.push({ property: 'box-shadow', value: 'var(--bs-box-shadow)' });
+    if (base === 'shadow-sm')
+        declarations.push({ property: 'box-shadow', value: 'var(--bs-box-shadow-sm)' });
+    if (base === 'shadow-lg')
+        declarations.push({ property: 'box-shadow', value: 'var(--bs-box-shadow-lg)' });
+    if (base === 'shadow-none')
+        declarations.push({ property: 'box-shadow', value: 'none' });
+    return declarations;
+}
+function bootstrapGridDeclarations(base) {
+    if (base === 'col') {
+        return [
+            { property: 'flex', value: '1 0 0%' },
+            { property: 'min-width', value: '0' },
+        ];
+    }
+    const colMatch = base.match(/^col-(\d{1,2})$/);
+    if (colMatch) {
+        const columns = Math.min(12, Math.max(1, Number(colMatch[1])));
+        const width = `${(columns / 12) * 100}%`;
+        return [
+            { property: 'flex', value: '0 0 auto' },
+            { property: 'width', value: width },
+        ];
+    }
+    const gapMatch = base.match(/^gap-([0-5])$/);
+    if (gapMatch)
+        return [{ property: 'gap', value: bootstrapSpacingScale[gapMatch[1]] }];
+    return [];
+}
+function categorizeResolvedStyleDeclarations(declarations) {
+    const categories = {};
+    for (const declaration of declarations) {
+        const category = resolvedStyleCategory(declaration.property);
+        categories[category] = (0, utils_1.uniqueBy)([...(categories[category] ?? []), declaration], (item) => `${item.className}:${item.property}:${item.value}:${item.source}:${item.selector ?? ''}`).slice(0, 80);
+    }
+    return categories;
+}
+function flattenResolvedStyleCategories(categories) {
+    return (0, utils_1.uniqueBy)(Object.values(categories).flat(), (declaration) => `${declaration.className}:${declaration.property}:${declaration.value}:${declaration.source}:${declaration.selector ?? ''}`);
+}
+function createStyleSystemEvidence(classes, declarations, styleContext) {
+    const classSystems = new Map();
+    for (const className of classes) {
+        const systems = new Set();
+        const base = (0, utils_1.classBase)(className).replace(/^!/, '');
+        if (styleContext?.classRules.has(className) ||
+            styleContext?.classRules.has(base) ||
+            styleContext?.classRules.has(base.replace(/^!/, ''))) {
+            systems.add('raw-css');
+        }
+        if (tailwindDeclarationsForClass(className, styleContext).length || isLikelyTailwindClass(className)) {
+            systems.add('tailwind');
+        }
+        if (bootstrapDeclarationsForClass(className, styleContext).length || isBootstrapClass(className)) {
+            systems.add('bootstrap');
+        }
+        if (!systems.size) {
+            systems.add('unknown');
+        }
+        classSystems.set(className, systems);
+    }
+    const observed = (0, utils_1.unique)([
+        ...Array.from(classSystems.values()).flatMap((systems) => Array.from(systems)),
+        ...declarations.map((declaration) => declaration.styleSystem),
+    ]).filter((system) => system !== 'unknown');
+    const unresolvedClasses = classes.filter((className) => classSystems.get(className)?.has('unknown'));
+    const classCounts = Object.fromEntries(['raw-css', 'tailwind', 'bootstrap', 'unknown'].map((system) => [
+        system,
+        Array.from(classSystems.values()).filter((systems) => systems.has(system)).length,
+    ]));
+    return omitEmptyRecord({
+        primary: observed.length === 1 ? observed[0] : observed.length > 1 ? 'mixed' : 'unknown',
+        observed,
+        projectDetected: styleContext?.detectedStyleSystems ?? [],
+        classCounts,
+        unresolvedClasses: unresolvedClasses.slice(0, 80),
+        declarationCounts: Object.fromEntries(['raw-css', 'tailwind', 'bootstrap'].map((system) => [
+            system,
+            declarations.filter((declaration) => declaration.styleSystem === system).length,
+        ])),
+    });
+}
+function isLikelyTailwindClass(className) {
+    const base = (0, utils_1.classBase)(className).replace(/^!/, '');
+    return Boolean(className.includes(':') ||
+        /\[[^\]]+\]/.test(base) ||
+        /^(?:bg|text|border|rounded|shadow|opacity|blur|backdrop|flex|grid|inline-flex|items|justify|content|self|place|gap|p[trblxy]?|m[trblxy]?|w|h|min-w|min-h|max-w|max-h|size|font|leading|tracking|uppercase|lowercase|capitalize|line-clamp|overflow|whitespace|truncate|relative|absolute|fixed|sticky|inset|top|right|bottom|left|z|col-span|row-span|from|via|to|fill|stroke)-/.test(base));
+}
+function resolvedStyleCategory(property) {
+    if (['color', 'background', 'background-color', 'fill', 'stroke'].includes(property)) {
+        return 'color';
+    }
+    if ([
+        'font-size',
+        'font-weight',
+        'line-height',
+        'letter-spacing',
+        'text-transform',
+        'text-align',
+        'font-family',
+    ].includes(property)) {
+        return 'typography';
+    }
+    if (/^(?:border|outline|ring)|border-radius/.test(property)) {
+        return 'border';
+    }
+    if (['box-shadow', 'opacity', 'filter', 'backdrop-filter'].includes(property)) {
+        return 'effects';
+    }
+    if (['transition', 'transition-property', 'transition-duration', 'animation', 'transform'].includes(property)) {
+        return 'motion';
+    }
+    if (property === 'display') {
+        return 'display';
+    }
+    if (/^(?:align|justify|place)/.test(property)) {
+        return 'alignment';
+    }
+    if (/^grid/.test(property)) {
+        return 'grid';
+    }
+    if (/^flex/.test(property)) {
+        return 'flex';
+    }
+    if (/^(?:padding|margin|gap|row-gap|column-gap)/.test(property)) {
+        return 'spacing';
+    }
+    if (/^(?:width|height|min-|max-)/.test(property)) {
+        return /^(?:min-|max-)/.test(property) ? 'minMax' : 'sizing';
+    }
+    if (['position', 'inset', 'top', 'right', 'bottom', 'left', 'z-index', 'object-fit'].includes(property)) {
+        return 'position';
+    }
+    if (['overflow', 'overflow-x', 'overflow-y'].includes(property)) {
+        return 'overflow';
+    }
+    if (['white-space', 'overflow-wrap', 'text-overflow', '-webkit-line-clamp'].includes(property)) {
+        return 'textFlow';
+    }
+    return 'layout';
+}
+function mergeResolvedStyleCategories(current, next) {
+    const merged = { ...current };
+    for (const [category, declarations] of Object.entries(next)) {
+        const existing = Array.isArray(merged[category])
+            ? merged[category]
+            : [];
+        merged[category] = (0, utils_1.uniqueBy)([...existing, ...declarations], (declaration) => `${declaration.className}:${declaration.property}:${declaration.value}:${declaration.source}:${declaration.selector ?? ''}`).slice(0, 80);
+    }
+    return omitEmptyRecord(merged);
+}
+function classBucketRecord(value) {
+    const buckets = {};
+    for (const [key, item] of Object.entries(value)) {
+        if (Array.isArray(item) && item.every((value) => typeof value === 'string')) {
+            buckets[key] = item;
+        }
+    }
+    return buckets;
+}
+function resolvedStyleRecord(value) {
+    return isRecordValue(value) ? value : {};
+}
+function createUiContract(input) {
+    const defaultClasses = (0, utils_1.unique)(input.defaultClasses?.length ? input.defaultClasses : input.classes);
+    const conditionalClasses = (0, utils_1.unique)(input.conditionalClasses ?? []);
+    const decorativeAccentClasses = (0, utils_1.unique)(input.decorativeAccentClasses ?? []);
+    const allClasses = (0, utils_1.unique)([...defaultClasses, ...conditionalClasses, ...decorativeAccentClasses]);
+    const grouped = input.classGroups ?? (0, extractors_1.groupTailwindClasses)(allClasses);
+    const resolvedStyles = categorizeResolvedStyleDeclarations(resolveUiClassDeclarations(allClasses, input.styleContext));
+    const styleSystemEvidence = createStyleSystemEvidence(allClasses, flattenResolvedStyleCategories(resolvedStyles), input.styleContext);
+    const responsiveVariants = createUiResponsiveVariants(allClasses, input.styleContext);
+    const interactionVariants = createUiInteractionVariants(allClasses, input.styleContext);
+    return {
+        identity: omitEmptyRecord({
+            kind: input.kind,
+            tag: input.tag,
+            layoutRole: input.layoutRole,
+            label: input.label,
+            line: input.line,
+            variants: input.variants,
+            props: input.props,
+            styleHelper: input.styleHelper,
+            styleHelperVariants: input.styleHelperVariants,
+        }),
+        semantics: omitEmptyRecord({
+            kind: input.kind,
+            role: input.semanticRole ?? input.layoutRole,
+            semanticRole: input.semanticRole,
+            semanticProfile: input.semanticProfile,
+            roleSignature: input.roleSignature,
+        }),
+        visual: omitEmptyRecord({
+            color: grouped.color ?? [],
+            typography: grouped.typography ?? [],
+            border: grouped.border ?? [],
+            effects: grouped.effects ?? [],
+            motion: grouped.motion ?? [],
+            decorativeAccentClasses,
+            resolvedStyles: omitEmptyRecord({
+                color: resolvedStyles.color,
+                typography: resolvedStyles.typography,
+                border: resolvedStyles.border,
+                effects: resolvedStyles.effects,
+                motion: resolvedStyles.motion,
+            }),
+        }),
+        layout: omitEmptyRecord({
+            display: filterUiContractClasses(allClasses, (className) => /^(?:flex|inline-flex|grid|inline-grid|block|inline|inline-block|hidden|contents|table)$/.test((0, utils_1.classBase)(className))),
+            alignment: filterUiContractClasses(allClasses, (className) => /^(?:items-|justify-|content-|self-|place-)/.test((0, utils_1.classBase)(className))),
+            grid: filterUiContractClasses(allClasses, (className) => /^(?:grid|grid-cols-|grid-rows-|auto-rows-|auto-cols-|col-|row-)/.test((0, utils_1.classBase)(className))),
+            flex: filterUiContractClasses(allClasses, (className) => /^(?:flex|inline-flex|flex-|basis-|grow|shrink)/.test((0, utils_1.classBase)(className))),
+            spacing: grouped.spacing ?? [],
+            sizing: grouped.sizing ?? [],
+            position: grouped.position ?? [],
+            layout: grouped.layout ?? [],
+            other: grouped.other ?? [],
+            resolvedStyles: omitEmptyRecord({
+                display: resolvedStyles.display,
+                alignment: resolvedStyles.alignment,
+                grid: resolvedStyles.grid,
+                flex: resolvedStyles.flex,
+                spacing: resolvedStyles.spacing,
+                sizing: resolvedStyles.sizing,
+                position: resolvedStyles.position,
+                layout: resolvedStyles.layout,
+            }),
+        }),
+        responsiveVariants,
+        interactionVariants,
+        safetyRules: omitEmptyRecord({
+            layoutSafety: input.layoutSafety,
+            scaleProfile: input.scaleProfile,
+            roleConstraints: input.roleSignature
+                ? omitEmptyRecord({
+                    preserveRole: input.roleSignature.role,
+                    preserveRoleGroup: input.roleSignature.roleGroup,
+                    preserveScale: input.roleSignature.scale,
+                    preserveDensity: input.roleSignature.density,
+                    preserveSurface: input.roleSignature.surface,
+                    preserveLayout: input.roleSignature.layout,
+                    exactClassFacts: input.roleSignature.exactClassFacts,
+                    flags: input.roleSignature.flags,
+                })
+                : undefined,
+            resolvedStyles: omitEmptyRecord({
+                textFlow: resolvedStyles.textFlow,
+                overflow: resolvedStyles.overflow,
+                minMax: resolvedStyles.minMax,
+            }),
+        }),
+        sourceEvidence: omitEmptyRecord({
+            extractor: 'ui.contract',
+            path: input.path,
+            line: input.line,
+            sourceHash: input.sourceHash,
+            confidence: input.confidence,
+            evidence: input.evidence,
+            classSource: input.classSource,
+            styleSystems: styleSystemEvidence,
+        }),
+    };
+}
+function createUiContractForElement(element, file, confidence, styleContext) {
+    return createUiContract({
+        kind: element.kind,
+        tag: element.originalTag,
+        layoutRole: element.layoutRole,
+        label: element.label,
+        line: element.line,
+        path: file?.relPath,
+        sourceHash: file?.sourceHash,
+        confidence,
+        evidence: element.evidence,
+        classSource: element.classSource,
+        classes: element.classes,
+        defaultClasses: element.defaultClasses,
+        conditionalClasses: element.conditionalClasses,
+        decorativeAccentClasses: element.decorativeAccentClasses,
+        classGroups: element.classGroups,
+        layoutSafety: element.layoutSafety,
+        responsiveProfile: element.responsiveProfile,
+        scaleProfile: element.scaleProfile,
+        semanticProfile: element.semanticProfile,
+        roleSignature: element.roleSignature,
+        variants: element.variants,
+        props: element.props,
+        styleHelper: element.styleHelper,
+        styleHelperVariants: element.styleHelperVariants,
+        styleContext,
+    });
+}
+function createUiContractForChild(child, styleContext) {
+    return createUiContract({
+        kind: child.kind,
+        tag: child.originalTag,
+        layoutRole: child.layoutRole,
+        semanticRole: child.semanticRole,
+        label: child.label,
+        classes: child.classes,
+        defaultClasses: child.defaultClasses,
+        conditionalClasses: child.conditionalClasses,
+        layoutSafety: child.layoutSafety,
+        responsiveProfile: child.responsiveProfile,
+        scaleProfile: child.scaleProfile,
+        semanticProfile: child.semanticProfile,
+        roleSignature: child.roleSignature,
+        variants: child.variants,
+        props: child.props,
+        styleHelper: child.styleHelper,
+        styleHelperVariants: child.styleHelperVariants,
+        styleContext,
+    });
+}
+function createUiPatternContract(input) {
+    const contract = createUiContract(input);
+    return {
+        ...contract,
+        identity: omitEmptyRecord({
+            ...contract.identity,
+            name: input.name,
+            count: input.count,
+        }),
+    };
+}
+function createUiRelationships(input) {
+    return {
+        ...(input.parentContext ? { parentContext: input.parentContext } : {}),
+        ...(input.childStructureContract
+            ? { childStructureContract: input.childStructureContract }
+            : {}),
+        ...(input.compoundStructure ? { compoundStructure: input.compoundStructure } : {}),
+        graphKeys: input.graphKeys ?? [],
+    };
+}
+function createUiResponsiveVariants(classes, styleContext) {
+    const variants = {};
+    for (const className of classes) {
+        const responsivePrefixes = responsivePrefixesForClass(className);
+        for (const responsivePrefix of responsivePrefixes) {
+            variants[responsivePrefix] = mergeUiContractClassBuckets(classBucketRecord(variants[responsivePrefix] ?? {}), uiContractClassBucket(className));
+            const resolved = categorizeResolvedStyleDeclarations(resolveUiClassDeclarations([className], styleContext));
+            variants[responsivePrefix].resolvedStyles = mergeResolvedStyleCategories(resolvedStyleRecord(variants[responsivePrefix].resolvedStyles), resolved);
+        }
+    }
+    return variants;
+}
+function createUiInteractionVariants(classes, styleContext) {
+    const variants = {};
+    for (const className of classes) {
+        const prefixes = className.split(':').slice(0, -1);
+        const statePrefixes = prefixes.filter(isInteractionPrefix);
+        for (const prefix of statePrefixes) {
+            variants[prefix] = mergeUiContractClassBuckets(classBucketRecord(variants[prefix] ?? {}), uiContractClassBucket(className));
+            const resolved = categorizeResolvedStyleDeclarations(resolveUiClassDeclarations([className], styleContext));
+            variants[prefix].resolvedStyles = mergeResolvedStyleCategories(resolvedStyleRecord(variants[prefix].resolvedStyles), resolved);
+        }
+    }
+    return variants;
+}
+function uiContractClassBucket(className) {
+    const base = (0, utils_1.classBase)(className);
+    if ((0, extractors_1.isLayoutClass)(className)) {
+        return { layout: [className] };
+    }
+    if ((0, extractors_1.isSpacingClass)(className)) {
+        return { spacing: [className] };
+    }
+    if ((0, extractors_1.isSizingClass)(className)) {
+        return { sizing: [className] };
+    }
+    if ((0, extractors_1.isTypographyClass)(className)) {
+        return { typography: [className] };
+    }
+    if (/^(?:bg-|from-|via-|to-|text-|decoration-|accent-|caret-|fill-|stroke-)/.test(base)) {
+        return { color: [className] };
+    }
+    if (/^(?:rounded|border|divide-|outline|ring)/.test(base)) {
+        return { border: [className] };
+    }
+    if (/^(?:shadow|opacity|blur|backdrop|mix-|bg-blend|drop-shadow|filter)/.test(base)) {
+        return { effects: [className] };
+    }
+    if (/^(?:absolute|relative|fixed|sticky|z-|overflow-|object-)/.test(base)) {
+        return { position: [className] };
+    }
+    if (/^(?:transition|duration|ease|delay|animate-|transform|scale-|rotate|translate-)/.test(base)) {
+        return { motion: [className] };
+    }
+    return { other: [className] };
+}
+function mergeUiContractClassBuckets(current, next) {
+    const merged = { ...current };
+    for (const [bucket, classes] of Object.entries(next)) {
+        merged[bucket] = (0, utils_1.unique)([...(merged[bucket] ?? []), ...classes]).slice(0, 120);
+    }
+    return merged;
+}
+function filterUiContractClasses(classes, predicate) {
+    return (0, utils_1.unique)(classes.filter(predicate)).slice(0, 120);
+}
+function isResponsivePrefix(prefix) {
+    return /^(?:sm|md|lg|xl|2xl|min-|max-)/.test(prefix);
+}
+function responsivePrefixesForClass(className) {
+    const prefixes = className.split(':').slice(0, -1).filter(isResponsivePrefix);
+    const bootstrapPrefixes = bootstrapResponsivePrefixes(className);
+    return (0, utils_1.unique)([...prefixes, ...bootstrapPrefixes]);
+}
+function isInteractionPrefix(prefix) {
+    return /^(?:hover|focus|focus-visible|focus-within|active|disabled|visited|checked|selected|open|dark|group|group-hover|peer|peer-hover|aria|data)/.test(prefix);
+}
+function omitEmptyRecord(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, item]) => {
+        if (item === undefined || item === null) {
+            return false;
+        }
+        if (Array.isArray(item)) {
+            return item.length > 0;
+        }
+        if (typeof item === 'object') {
+            return Object.keys(item).length > 0;
+        }
+        return true;
+    }));
+}
+function mergeLayoutSafetyProfiles(items) {
+    const profiles = items.map((item) => item.layoutSafety).filter(isLayoutSafetyProfile);
+    if (!profiles.length) {
+        return undefined;
+    }
+    const merged = {
+        wrapClasses: (0, utils_1.unique)(profiles.flatMap((profile) => profile.wrapClasses)).slice(0, 80),
+        overflowClasses: (0, utils_1.unique)(profiles.flatMap((profile) => profile.overflowClasses)).slice(0, 80),
+        minSizeClasses: (0, utils_1.unique)(profiles.flatMap((profile) => profile.minSizeClasses)).slice(0, 80),
+        maxSizeClasses: (0, utils_1.unique)(profiles.flatMap((profile) => profile.maxSizeClasses)).slice(0, 80),
+        fitClasses: (0, utils_1.unique)(profiles.flatMap((profile) => profile.fitClasses)).slice(0, 80),
+        flexBehaviorClasses: (0, utils_1.unique)(profiles.flatMap((profile) => profile.flexBehaviorClasses)).slice(0, 80),
+        layoutSafetyClasses: (0, utils_1.unique)(profiles.flatMap((profile) => profile.layoutSafetyClasses)).slice(0, 120),
+    };
+    return merged.layoutSafetyClasses.length ? merged : undefined;
+}
+function mergeResponsiveProfiles(items) {
+    const profiles = items.map((item) => item.responsiveProfile).filter(isResponsiveProfile);
+    if (!profiles.length) {
+        return undefined;
+    }
+    const breakpoints = {};
+    for (const profile of profiles) {
+        for (const [breakpoint, classes] of Object.entries(profile.breakpoints)) {
+            breakpoints[breakpoint] = (0, utils_1.unique)([...(breakpoints[breakpoint] ?? []), ...classes]).slice(0, 80);
+        }
+    }
+    const merged = {
+        breakpoints,
+        layoutClasses: (0, utils_1.unique)(profiles.flatMap((profile) => profile.layoutClasses)).slice(0, 120),
+        typographyClasses: (0, utils_1.unique)(profiles.flatMap((profile) => profile.typographyClasses)).slice(0, 120),
+        spacingClasses: (0, utils_1.unique)(profiles.flatMap((profile) => profile.spacingClasses)).slice(0, 120),
+        sizingClasses: (0, utils_1.unique)(profiles.flatMap((profile) => profile.sizingClasses)).slice(0, 120),
+        visibilityClasses: (0, utils_1.unique)(profiles.flatMap((profile) => profile.visibilityClasses)).slice(0, 120),
+        stateClasses: (0, utils_1.unique)(profiles.flatMap((profile) => profile.stateClasses)).slice(0, 120),
+    };
+    return Object.keys(merged.breakpoints).length ? merged : undefined;
+}
+function mergeScaleProfiles(items) {
+    const profiles = items.map((item) => item.scaleProfile).filter(isScaleProfile);
+    if (!profiles.length) {
+        return undefined;
+    }
+    const merged = {
+        typographyClasses: (0, utils_1.unique)(profiles.flatMap((profile) => profile.typographyClasses)).slice(0, 120),
+        spacingClasses: (0, utils_1.unique)(profiles.flatMap((profile) => profile.spacingClasses)).slice(0, 120),
+        sizingClasses: (0, utils_1.unique)(profiles.flatMap((profile) => profile.sizingClasses)).slice(0, 120),
+        gapClasses: (0, utils_1.unique)(profiles.flatMap((profile) => profile.gapClasses)).slice(0, 80),
+        maxWidthClasses: (0, utils_1.unique)(profiles.flatMap((profile) => profile.maxWidthClasses)).slice(0, 80),
+        lineHeightClasses: (0, utils_1.unique)(profiles.flatMap((profile) => profile.lineHeightClasses)).slice(0, 80),
+    };
+    return Object.values(merged).some((classes) => classes.length) ? merged : undefined;
+}
+function mergeSemanticProfiles(items) {
+    const profiles = items.map((item) => item.semanticProfile).filter(isSemanticProfile);
+    if (!profiles.length) {
+        return undefined;
     }
+    return {
+        roles: (0, utils_1.unique)(profiles.flatMap((profile) => profile.roles)).slice(0, 40),
+        isCompound: profiles.some((profile) => profile.isCompound),
+        hasIcon: profiles.some((profile) => profile.hasIcon),
+        hasDivider: profiles.some((profile) => profile.hasDivider),
+        hasImage: profiles.some((profile) => profile.hasImage),
+        hasMultipleTextStyles: profiles.some((profile) => profile.hasMultipleTextStyles),
+        textStyleCount: Math.max(...profiles.map((profile) => profile.textStyleCount)),
+        childCount: Math.max(...profiles.map((profile) => profile.childCount)),
+    };
 }
-function backendCallKey(call) {
-    return (0, utils_1.toRegistryKey)('service', (0, backend_1.backendReceiverToClassName)(call.receiver));
+function summarizePatternLayoutSafety(elements) {
+    return mergeLayoutSafetyProfiles([
+        ...elements,
+        ...elements.flatMap((element) => element.childSummary ?? []),
+    ]);
 }
-function uniqueSideEffectsForRecipe(sideEffects) {
-    return (0, utils_1.uniqueBy)(sideEffects, (sideEffect) => `${sideEffect.kind}.${sideEffect.target ?? ''}.${sideEffect.operation ?? ''}.${sideEffect.line}`);
+function summarizePatternResponsiveProfile(elements) {
+    return mergeResponsiveProfiles([
+        ...elements,
+        ...elements.flatMap((element) => element.childSummary ?? []),
+    ]);
 }
-function sourceInfo(extractor, confidence, evidence, file) {
+function summarizePatternScaleProfile(elements) {
+    return mergeScaleProfiles([
+        ...elements,
+        ...elements.flatMap((element) => element.childSummary ?? []),
+    ]);
+}
+function summarizePatternSemanticProfile(elements) {
+    return mergeSemanticProfiles(elements);
+}
+function summarizePatternRoleSignatures(elements) {
+    return (0, utils_1.uniqueBy)(elements
+        .map((element) => element.roleSignature)
+        .filter((value) => Boolean(value)), (signature) => roleSignatureKey(signature)).slice(0, 12);
+}
+function summarizeParentContexts(elements) {
+    const elementsWithParent = elements.filter((element) => element.parentClasses?.length);
+    const grouped = (0, utils_1.groupBy)(elementsWithParent, (element) => [
+        element.parentKind ?? 'unknown-parent',
+        element.parentTag ?? 'unknown-tag',
+        JSON.stringify(element.parentClassGroups ?? (0, extractors_1.groupTailwindClasses)(element.parentClasses ?? [])),
+    ].join(':'));
+    return Array.from(grouped.values())
+        .map((group) => {
+        const first = group[0];
+        const parentClasses = (0, utils_1.unique)(group.flatMap((element) => element.parentClasses ?? [])).slice(0, 80);
+        return {
+            parentKind: first?.parentKind,
+            parentTag: first?.parentTag,
+            count: group.length,
+            parentClasses,
+            parentClassGroups: (0, extractors_1.mergeClassGroups)(group
+                .map((element) => element.parentClassGroups)
+                .filter((value) => Boolean(value))),
+            childKinds: (0, utils_1.unique)(group.map((element) => element.kind)).slice(0, 24),
+            layoutRoles: (0, utils_1.unique)(group
+                .map((element) => element.layoutRole)
+                .filter((value) => Boolean(value))).slice(0, 24),
+        };
+    })
+        .sort((a, b) => Number(b.count) - Number(a.count))
+        .slice(0, 12);
+}
+function summarizeElementChildContract(children, styleContext) {
+    if (!children.length) {
+        return undefined;
+    }
     return {
-        extractor,
-        confidence,
-        evidence,
-        path: file.relPath,
-        hash: file.sourceHash,
+        directChildCount: children.length,
+        childOrder: children.slice(0, 12).map((child) => ({
+            kind: child.kind,
+            tag: child.originalTag,
+            layoutRole: child.layoutRole,
+            semanticRole: child.semanticRole,
+            roleSignature: child.roleSignature,
+            labelHint: child.label ? labelSignature(child.label) : undefined,
+            label: child.label,
+            uiContract: createUiContractForChild(child, styleContext),
+            defaultClasses: (child.defaultClasses?.length ? child.defaultClasses : child.classes).slice(0, 48),
+            layoutSafety: child.layoutSafety,
+            scaleProfile: child.scaleProfile,
+            classGroups: (0, extractors_1.groupTailwindClasses)(child.defaultClasses?.length ? child.defaultClasses : child.classes),
+        })),
+        childKinds: (0, utils_1.unique)(children.map((child) => child.kind)).slice(0, 24),
+        semanticRoles: (0, utils_1.unique)(children
+            .map((child) => child.semanticRole)
+            .filter((value) => Boolean(value))).slice(0, 24),
+        layoutRoles: (0, utils_1.unique)(children.map((child) => child.layoutRole).filter((value) => Boolean(value))).slice(0, 24),
     };
 }
-function toGraphNode(key, kind, name, relPath, file, extractor, facets) {
+function summarizePatternChildStructure(elements, styleContext) {
+    const childSummaries = elements
+        .map((element) => element.childSummary ?? [])
+        .filter((children) => children.length);
+    if (!childSummaries.length) {
+        return undefined;
+    }
+    const childCounts = childSummaries.map((children) => children.length);
+    const childOrderExamples = (0, utils_1.uniqueBy)(childSummaries
+        .map((children) => summarizeElementChildContract(children, styleContext))
+        .filter((summary) => Boolean(summary)), (summary) => JSON.stringify(summary)).slice(0, 8);
     return {
-        k: key,
-        kind,
-        name,
-        path: relPath,
-        language: file.language,
-        framework: detectFrameworkForFile(file),
-        ...(facets ? { facets } : {}),
-        source: sourceInfo(extractor, 'high', [`path:${relPath}`], file),
+        preserveDirectChildRelationships: true,
+        directChildCountRange: {
+            min: Math.min(...childCounts),
+            max: Math.max(...childCounts),
+        },
+        childKinds: (0, utils_1.unique)(childSummaries.flatMap((children) => children.map((child) => child.kind))).slice(0, 32),
+        childOrderExamples,
     };
 }
-function toGraphEdge(from, to, type, extractor, file, confidence = 'high') {
+function summarizeCompoundStructure(elements, styleContext) {
+    const compoundElements = elements.filter((element) => element.semanticProfile?.isCompound);
+    if (!compoundElements.length) {
+        return undefined;
+    }
+    const childCounts = compoundElements.map((element) => element.childSummary?.length ?? 0);
+    const childOrderExamples = (0, utils_1.uniqueBy)(compoundElements
+        .map((element) => summarizeElementChildContract(element.childSummary ?? [], styleContext))
+        .filter((summary) => Boolean(summary)), (summary) => JSON.stringify(summary)).slice(0, 8);
+    const semanticProfile = summarizePatternSemanticProfile(compoundElements);
     return {
-        from,
-        to,
-        type,
-        confidence,
-        source: sourceInfo(extractor, confidence, [`${from} ${type} ${to}`], file),
+        preserveCompoundChildren: true,
+        preserveIconAndDividerRoles: Boolean(semanticProfile?.hasIcon || semanticProfile?.hasDivider),
+        preserveMultipleTextSegments: Boolean(semanticProfile?.hasMultipleTextStyles),
+        directChildCountRange: {
+            min: Math.min(...childCounts),
+            max: Math.max(...childCounts),
+        },
+        semanticRoles: semanticProfile?.roles ?? [],
+        childOrderExamples,
     };
 }
-function addRenderEdges(entries, files, edges) {
-    const componentKeysByName = new Map();
-    for (const entry of entries.filter((item) => item.group === 'component')) {
-        const name = typeof entry.value.name === 'string' ? entry.value.name : undefined;
-        if (name) {
-            componentKeysByName.set(name, entry.key);
-        }
+function createUiGenerationConstraints(kind, elements, decorativeAccentClasses) {
+    const layoutSafety = summarizePatternLayoutSafety(elements);
+    const responsiveProfile = summarizePatternResponsiveProfile(elements);
+    const scaleProfile = summarizePatternScaleProfile(elements);
+    const roleSignatures = summarizePatternRoleSignatures(elements);
+    const parentContexts = summarizeParentContexts(elements);
+    const childStructure = summarizePatternChildStructure(elements);
+    const compoundStructure = summarizeCompoundStructure(elements);
+    return {
+        preserveRootAndChildrenTogether: true,
+        preserveParentLayoutContext: Boolean(parentContexts.length),
+        preserveDirectChildRelationships: Boolean(childStructure),
+        preserveCompoundChildRoles: Boolean(compoundStructure),
+        avoidUnobservedChildren: ['card', 'form', 'nav', 'section', 'table', 'dialog'].includes(kind) ||
+            Boolean(compoundStructure),
+        preserveResponsiveBreakpoints: Boolean(responsiveProfile),
+        preserveLayoutSafety: Boolean(layoutSafety),
+        preserveScaleBounds: Boolean(scaleProfile),
+        preserveRoleSignatures: Boolean(roleSignatures.length),
+        avoidDefaultDecorativeAccents: Boolean(decorativeAccentClasses.length),
+    };
+}
+function createUiGenerationGuidance(kind, elements) {
+    const guidance = [];
+    const elementClasses = new Set(elements.flatMap((element) => [
+        ...element.classes,
+        ...(element.defaultClasses ?? []),
+        ...(element.conditionalClasses ?? []),
+        ...(element.parentClasses ?? []),
+    ]));
+    if (kind === 'card') {
+        guidance.push('Use rootDefaultClasses for the outer card shell. Use elementPatterns for nested panels, slots, bullets, and footer layout instead of merging every class onto the root.', 'Preserve the observed child structure for cards. Do not add decorative children, progress bars, icons, or extra badges unless those children exist in childStructure or the task explicitly asks for them.');
     }
-    for (const file of files) {
-        if (!file.routes.length || !file.jsxElements.length) {
-            continue;
-        }
-        for (const route of file.routes) {
-            const routeKey = (0, utils_1.toRegistryKey)('route', route);
-            for (const jsxElement of file.jsxElements) {
-                const componentKey = componentKeysByName.get(jsxElement);
-                if (componentKey) {
-                    edges.push(toGraphEdge(routeKey, componentKey, 'renders', 'react-jsx', file));
-                }
-            }
-        }
+    if (kind === 'button') {
+        guidance.push('Choose button variants by actionUsages/variantRoles. Ghost and link-style actions are low-emphasis; do not use them for primary CTAs or form submits.', 'Preserve button display, height, padding, no-wrap, and shrink/min-width classes together so labels do not wrap or collapse.');
+    }
+    if (kind === 'badge' && summarizeCompoundStructure(elements)) {
+        guidance.push('Compound badges, hero eyebrows, and brand chips are connected lockups. Preserve icon/image children, dividers, text segments, child order, compact spacing, and separate text styles instead of collapsing them into one text-only pill.');
+    }
+    if (kind === 'heading') {
+        guidance.push('Preserve observed heading scale, max-width, line-height, and responsive typography classes. Do not upscale headings beyond the captured scaleProfile.');
+    }
+    if (['section', 'layout', 'form', 'nav'].includes(kind)) {
+        guidance.push('Preserve parent grid/flex context, responsive breakpoints, and child order as layout contracts instead of recreating the section from isolated tokens.');
+    }
+    if (elements.some((element) => element.conditionalClasses?.length)) {
+        guidance.push('conditionalClasses describe state or variant changes; apply them only when the matching condition, selected state, or variant is present.');
+    }
+    if (elementClasses.has('section-frame') || elementClasses.has('sm:section-frame')) {
+        guidance.push('section-frame is a framed surface paint model with its own clipped section-frame::before grid overlay; preserve which element owns that frame.');
+    }
+    if (elementClasses.has('section-frame') && elementClasses.has('context-surface')) {
+        guidance.push('When section-frame and context-surface appear together, keep the pairing so direct children remain above the parent grid overlay.');
+    }
+    if (elements.some((element) => (element.childSummary ?? []).some((child) => (child.defaultClasses ?? child.classes).some((className) => className === 'section-frame')))) {
+        guidance.push('Nested framed child surfaces need their own section-frame/context-surface classes when the source design gives each child a separate grid origin.');
+    }
+    if (summarizePatternLayoutSafety(elements)) {
+        guidance.push('layoutSafety records wrapping, overflow, min/max size, and flex behavior that prevent text collision and button/card overflow. Keep those classes with the element that owns them.');
+    }
+    if (summarizeParentContexts(elements).length) {
+        guidance.push('parentContexts records the grid/flex surface that owns this pattern. Preserve that parent relationship when generating repeated cards or nested panels.');
+    }
+    if (summarizePatternResponsiveProfile(elements)) {
+        guidance.push('responsiveProfile is part of the contract. Keep mobile, tablet, and desktop variants attached to the same elements as the source.');
+    }
+    if (summarizePatternRoleSignatures(elements).length) {
+        guidance.push('roleSignatures are part of the contract. Similar-looking UI with different role, scale, density, surface, layout, or exactClassFacts is a different generation target.');
+    }
+    return guidance;
+}
+function summarizeActionUsages(elements) {
+    return elements.slice(0, 80).flatMap((element) => {
+        const variantNames = actionVariantNamesForElement(element);
+        return variantNames.map((variantName) => ({
+            label: element.label,
+            tag: element.originalTag,
+            line: element.line,
+            variant: variantName,
+            size: element.variants?.size,
+            type: element.variants?.type ?? element.type,
+            styleHelper: element.styleHelper,
+            parentKind: element.parentKind,
+            parentLayoutRole: element.parentKind ? element.layoutRole : undefined,
+            ...inferActionVariantRole(variantName, [
+                ...(element.defaultClasses ?? []),
+                ...(element.classes ?? []),
+            ]),
+        }));
+    });
+}
+function actionVariantNamesForElement(element) {
+    const variantValue = element.variants?.variant ?? element.styleHelperVariants?.variant;
+    if (!variantValue && /button/i.test(element.styleHelper ?? '')) {
+        return ['default'];
     }
+    if (!variantValue) {
+        return ['custom'];
+    }
+    const quotedValues = Array.from(variantValue.matchAll(/["']([^"']+)["']/g)).map((match) => match[1]);
+    if (quotedValues.length) {
+        return (0, utils_1.unique)(quotedValues).slice(0, 6);
+    }
+    return (0, utils_1.unique)(variantValue
+        .split('|')
+        .map((value) => value.trim())
+        .filter(Boolean)).slice(0, 6);
 }
-function addUiPatternRules(entries, usedKeys, nodes, edges, files) {
+function addUiPatternRules(entries, usedKeys, nodes, edges, files, styleContext) {
     for (const file of files) {
+        if ((0, extractors_1.isTestFile)(file.relPath)) {
+            continue;
+        }
         const elementsByKind = (0, utils_1.groupBy)(file.uiElements, (element) => element.kind);
         for (const [kind, elements] of elementsByKind) {
             if (!elements.length || kind === 'unknown' || kind === 'link') {
@@ -734,6 +2978,62 @@ function addUiPatternRules(entries, usedKeys, nodes, edges, files) {
             const decorativeAccentClasses = (0, extractors_1.filterClasses)(classes, extractors_1.isDecorativeAccentClass).slice(0, 40);
             const classGroups = (0, extractors_1.mergeClassGroups)(elements.map((element) => element.classGroups ?? {}));
             const variants = (0, extractors_1.mergeVariantProps)(elements.map((element) => element.variants ?? {}));
+            const elementPatterns = summarizeUiElementPatterns(elements, styleContext);
+            const layoutSafety = summarizePatternLayoutSafety(elements);
+            const responsiveProfile = summarizePatternResponsiveProfile(elements);
+            const scaleProfile = summarizePatternScaleProfile(elements);
+            const semanticProfile = summarizePatternSemanticProfile(elements);
+            const roleSignatures = summarizePatternRoleSignatures(elements);
+            const parentContexts = summarizeParentContexts(elements);
+            const childStructureContract = summarizePatternChildStructure(elements, styleContext);
+            const compoundStructure = summarizeCompoundStructure(elements, styleContext);
+            const generationConstraints = createUiGenerationConstraints(kind, elements, decorativeAccentClasses);
+            const structuralRootElements = rootUiElementsForKind(elements);
+            const rootDefaultClasses = (0, utils_1.unique)(structuralRootElements.flatMap((element) => element.defaultClasses ?? element.classes)).slice(0, 80);
+            const recipeDefaultClasses = kind === 'card' && rootDefaultClasses.length ? rootDefaultClasses : defaultClasses;
+            const nestedDefaultClasses = kind === 'card'
+                ? (0, utils_1.unique)(elements
+                    .filter((element) => !structuralRootElements.includes(element))
+                    .flatMap((element) => element.defaultClasses ?? element.classes)
+                    .filter((className) => !(0, extractors_1.isDecorativeAccentClass)(className))).slice(0, 80)
+                : undefined;
+            const actionUsages = kind === 'button' ? summarizeActionUsages(elements) : undefined;
+            const uiContract = createUiPatternContract({
+                name: `${(0, utils_1.titleCase)(kind)} pattern`,
+                count: elements.length,
+                kind,
+                tag: structuralRootElements[0]?.originalTag,
+                layoutRole: structuralRootElements[0]?.layoutRole,
+                label: structuralRootElements[0]?.label,
+                line: structuralRootElements[0]?.line,
+                path: file.relPath,
+                sourceHash: file.sourceHash,
+                confidence: elements.length > 1 ? 'medium' : 'low',
+                evidence: structuralRootElements[0]?.evidence,
+                classSource: structuralRootElements[0]?.classSource,
+                classes,
+                defaultClasses: recipeDefaultClasses,
+                conditionalClasses,
+                decorativeAccentClasses,
+                classGroups,
+                layoutSafety,
+                responsiveProfile,
+                scaleProfile,
+                semanticProfile,
+                roleSignature: roleSignatures[0],
+                variants,
+                styleContext,
+            });
+            uiContract.safetyRules = omitEmptyRecord({
+                ...uiContract.safetyRules,
+                generationConstraints,
+            });
+            const relationships = createUiRelationships({
+                parentContext: parentContexts,
+                childStructureContract,
+                compoundStructure,
+                graphKeys: dependencies,
+            });
             addEntry(entries, usedKeys, {
                 key: ruleKey,
                 group: 'rule',
@@ -744,8 +3044,30 @@ function addUiPatternRules(entries, usedKeys, nodes, edges, files) {
                     kind,
                     ...Object.keys(variants),
                     ...Object.values(variants).flatMap((values) => values),
-                    ...defaultClasses.slice(0, 20),
+                    ...recipeDefaultClasses.slice(0, 20),
                     ...(decorativeAccentClasses.length ? ['decorative-accent', 'highlight-only'] : []),
+                    ...(layoutSafety
+                        ? ['layout-safety', ...layoutSafety.layoutSafetyClasses.slice(0, 16)]
+                        : []),
+                    ...(responsiveProfile ? ['responsive-contract'] : []),
+                    ...(scaleProfile ? ['scale-contract'] : []),
+                    ...(roleSignatures.length
+                        ? [
+                            'role-signature',
+                            ...roleSignatures.flatMap((signature) => [
+                                signature.role,
+                                signature.roleGroup,
+                                signature.scale,
+                                signature.density,
+                                signature.surface,
+                                signature.layout,
+                                ...signature.flags,
+                            ]),
+                        ]
+                        : []),
+                    ...(semanticProfile?.isCompound
+                        ? ['compound-ui', 'compound-badge', ...semanticProfile.roles]
+                        : []),
                 ]),
                 dependencies,
                 usedBy: [],
@@ -759,12 +3081,30 @@ function addUiPatternRules(entries, usedKeys, nodes, edges, files) {
                     concept: kind,
                     path: file.relPath,
                     classes,
-                    defaultClasses,
+                    defaultClasses: recipeDefaultClasses,
+                    rootDefaultClasses,
+                    ...(nestedDefaultClasses?.length ? { nestedDefaultClasses } : {}),
                     conditionalClasses,
                     decorativeAccentClasses,
-                    guidance: (0, extractors_1.createUiPatternGuidance)(kind, decorativeAccentClasses),
+                    ...(layoutSafety ? { layoutSafety } : {}),
+                    ...(responsiveProfile ? { responsiveProfile } : {}),
+                    ...(scaleProfile ? { scaleProfile } : {}),
+                    ...(semanticProfile ? { semanticProfile } : {}),
+                    ...(roleSignatures.length ? { roleSignatures } : {}),
+                    ...(parentContexts.length ? { parentContexts } : {}),
+                    ...(childStructureContract ? { childStructureContract } : {}),
+                    ...(compoundStructure ? { compoundStructure } : {}),
+                    generationConstraints,
+                    uiContract,
+                    relationships,
+                    guidance: (0, utils_1.unique)([
+                        ...(0, extractors_1.createUiPatternGuidance)(kind, decorativeAccentClasses),
+                        ...createUiGenerationGuidance(kind, elements),
+                    ]),
                     classGroups,
                     variants,
+                    elementPatterns,
+                    ...(actionUsages ? { actionUsages } : {}),
                     elements: elements.slice(0, 80),
                     sourceHash: file.sourceHash,
                     source: sourceInfo('ui.patterns', elements.length > 1 ? 'medium' : 'low', [`${kind}:${elements.length}`], file),
@@ -773,8 +3113,12 @@ function addUiPatternRules(entries, usedKeys, nodes, edges, files) {
             nodes.push(toGraphNode(ruleKey, 'rule', `${kind} pattern`, file.relPath, file, 'ui.patterns', {
                 ui: {
                     concept: kind,
-                    classes: defaultClasses,
+                    classes: rootDefaultClasses.length ? rootDefaultClasses : defaultClasses,
                     decorativeAccentClasses,
+                    layoutSafety,
+                    responsiveProfile,
+                    scaleProfile,
+                    semanticProfile,
                     classGroups,
                     variants,
                     count: elements.length,
@@ -784,8 +3128,11 @@ function addUiPatternRules(entries, usedKeys, nodes, edges, files) {
         }
     }
 }
-function addUiCompositionRules(entries, usedKeys, nodes, edges, files) {
+function addUiCompositionRules(entries, usedKeys, nodes, edges, files, styleContext) {
     for (const file of files) {
+        if ((0, extractors_1.isTestFile)(file.relPath)) {
+            continue;
+        }
         if (!file.uiElements.length && !file.classExpressions.length) {
             continue;
         }
@@ -819,6 +3166,46 @@ function addUiCompositionRules(entries, usedKeys, nodes, edges, files) {
         const classExpressionsByTarget = (0, extractors_1.groupClassExpressionsByTarget)(file.classExpressions);
         const layoutRoles = (0, utils_1.unique)(file.uiElements.flatMap((element) => element.layoutRole ?? []));
         const elementKinds = (0, utils_1.unique)(file.uiElements.map((element) => element.kind));
+        const layoutSafety = summarizePatternLayoutSafety(file.uiElements);
+        const responsiveProfile = summarizePatternResponsiveProfile(file.uiElements);
+        const scaleProfile = summarizePatternScaleProfile(file.uiElements);
+        const semanticProfile = summarizePatternSemanticProfile(file.uiElements);
+        const parentContexts = summarizeParentContexts(file.uiElements);
+        const childStructureContract = summarizePatternChildStructure(compositionElements, styleContext);
+        const compoundStructure = summarizeCompoundStructure(file.uiElements, styleContext);
+        const uiContract = createUiPatternContract({
+            name: `${file.relPath} UI composition`,
+            count: file.uiElements.length,
+            kind: 'composition',
+            tag: compositionElements[0]?.originalTag,
+            layoutRole: layoutRoles[0],
+            line: compositionElements[0]?.line,
+            path: file.relPath,
+            sourceHash: file.sourceHash,
+            confidence: file.components.length || file.routes.length ? 'high' : 'medium',
+            evidence: compositionElements[0]?.evidence,
+            classSource: compositionElements[0]?.classSource,
+            classes: baseClassReferences,
+            defaultClasses: baseClassReferences,
+            conditionalClasses,
+            decorativeAccentClasses,
+            classGroups: (0, extractors_1.mergeClassGroups)(compositionElements.map((element) => element.classGroups ?? {})),
+            layoutSafety,
+            responsiveProfile,
+            scaleProfile,
+            semanticProfile,
+            styleContext,
+        });
+        uiContract.safetyRules = omitEmptyRecord({
+            ...uiContract.safetyRules,
+            compositionGuidance: (0, extractors_1.createUiCompositionGuidance)(file),
+        });
+        const relationships = createUiRelationships({
+            parentContext: parentContexts,
+            childStructureContract,
+            compoundStructure,
+            graphKeys: dependencies,
+        });
         addEntry(entries, usedKeys, {
             key: ruleKey,
             group: 'rule',
@@ -840,6 +3227,14 @@ function addUiCompositionRules(entries, usedKeys, nodes, edges, files) {
                 ...responsiveClasses.slice(0, 24),
                 ...surfaceClasses.slice(0, 24),
                 ...(decorativeAccentClasses.length ? ['decorative-accent', 'highlight-only'] : []),
+                ...(layoutSafety
+                    ? ['layout-safety', ...layoutSafety.layoutSafetyClasses.slice(0, 24)]
+                    : []),
+                ...(responsiveProfile ? ['responsive-contract'] : []),
+                ...(scaleProfile ? ['scale-contract'] : []),
+                ...(semanticProfile?.isCompound
+                    ? ['compound-ui', 'compound-badge', ...semanticProfile.roles]
+                    : []),
                 ...spacingClasses.slice(0, 24),
                 ...typographyClasses.slice(0, 24),
             ]),
@@ -865,6 +3260,15 @@ function addUiCompositionRules(entries, usedKeys, nodes, edges, files) {
                 conditionalClasses,
                 decorativeAccentClasses,
                 typographyClasses,
+                ...(layoutSafety ? { layoutSafety } : {}),
+                ...(responsiveProfile ? { responsiveProfile } : {}),
+                ...(scaleProfile ? { scaleProfile } : {}),
+                ...(semanticProfile ? { semanticProfile } : {}),
+                ...(parentContexts.length ? { parentContexts } : {}),
+                ...(childStructureContract ? { childStructureContract } : {}),
+                ...(compoundStructure ? { compoundStructure } : {}),
+                uiContract,
+                relationships,
                 componentSlots: (0, extractors_1.buildComponentSlots)(file.uiElements),
                 classExpressionsByTarget,
                 elements: compositionElements,
@@ -883,6 +3287,10 @@ function addUiCompositionRules(entries, usedKeys, nodes, edges, files) {
                 routes: file.routes,
                 layoutRoles,
                 elementKinds,
+                layoutSafety,
+                responsiveProfile,
+                scaleProfile,
+                semanticProfile,
             },
         }));
         edges.push(toGraphEdge(file.key, ruleKey, 'defines_ui_composition', 'ui.composition', file));
@@ -894,8 +3302,175 @@ function addUiCompositionRules(entries, usedKeys, nodes, edges, files) {
         }
     }
 }
-function addConnectedPatternRules(entries, usedKeys, nodes, edges, reviewItems, files) {
-    const clusters = buildConnectedPatternClusters(files);
+function addGlobalUiContractRules(entries, usedKeys, nodes, edges, files) {
+    const eligibleFiles = files.filter((file) => !(0, extractors_1.isTestFile)(file.relPath));
+    const shellFiles = eligibleFiles.filter(hasPageShellContractEvidence);
+    const framedSurfaceFiles = eligibleFiles.filter(hasFramedSurfaceContractEvidence);
+    if (shellFiles.length) {
+        const primary = shellFiles[0];
+        const ruleKey = (0, utils_1.toRegistryKey)('rule', 'ui.page-shell.global');
+        const cssRules = cssRuleSnapshots(shellFiles, shellCssRuleMatches).slice(0, 48);
+        const classes = collectClassEvidence(shellFiles, (className) => /^(?:app-shell|bg-background|min-h-screen|flex|flex-col|text-foreground)$/.test(className));
+        addEntry(entries, usedKeys, {
+            key: ruleKey,
+            group: 'rule',
+            summary: 'Global page shell contract: body/app-shell owns the page background, route roots stay transparent.',
+            tags: (0, utils_1.unique)([
+                'rule',
+                'ui',
+                'global',
+                'page-shell',
+                'app-shell',
+                'body-background',
+                'route-root',
+                'transparent-root',
+                'bg-background',
+                ...classes,
+            ]),
+            dependencies: contractDependencies(shellFiles),
+            usedBy: [],
+            confidence: 'high',
+            status: 'inferred',
+            path: primary.relPath,
+            value: {
+                name: 'Global page shell contract',
+                kind: 'rule',
+                ruleType: 'ui-page-shell',
+                backgroundOwner: 'body/app-shell',
+                keepRouteRootsTransparent: true,
+                classes,
+                requiredShellClasses: collectClassEvidence(shellFiles, (className) => /^(?:app-shell|min-h-screen|flex|flex-col)$/.test(className)),
+                avoidOnRouteRoot: ['bg-background', 'min-h-screen bg-background'],
+                routeRootGuidance: [
+                    'Route-level page roots inside app-shell should stay transparent; do not add bg-background or a solid page wrapper unless the source route deliberately owns an isolated full-screen surface.',
+                    'Let body/app-shell own the global gradient/glow/background and min-height behavior; page content should add spacing, containers, and sections without covering that shell.',
+                    'If a generated page needs full-height layout, prefer flex/min-height on the existing shell/layout contract instead of introducing a new bg-background root.',
+                ],
+                cssRules,
+                sourceHash: primary.sourceHash,
+                source: sourceInfo('ui.global-contracts', 'high', shellFiles.slice(0, 20).map((file) => `path:${file.relPath}`), primary),
+            },
+        });
+        nodes.push(toGraphNode(ruleKey, 'rule', 'Global page shell contract', primary.relPath, primary, 'ui.global-contracts', {
+            ui: {
+                ruleType: 'ui-page-shell',
+                backgroundOwner: 'body/app-shell',
+                keepRouteRootsTransparent: true,
+                classes,
+            },
+        }));
+        for (const file of shellFiles.slice(0, 80)) {
+            edges.push(toGraphEdge(file.key, ruleKey, 'defines_ui_contract', 'ui.global-contracts', file));
+            if (hasStyleSurface(file)) {
+                edges.push(toGraphEdge(styleKeyForFile(file), ruleKey, 'defines_ui_contract', 'ui.global-contracts', file));
+            }
+        }
+    }
+    if (framedSurfaceFiles.length) {
+        const primary = framedSurfaceFiles[0];
+        const ruleKey = (0, utils_1.toRegistryKey)('rule', 'ui.surface.section-frame-grid');
+        const cssRules = cssRuleSnapshots(framedSurfaceFiles, framedSurfaceCssRuleMatches).slice(0, 48);
+        const classes = collectClassEvidence(framedSurfaceFiles, (className) => /^(?:section-frame|sm:section-frame|context-surface|bg-card|bg-\[var\(--surface-soft\)\]|rounded)/.test(className));
+        addEntry(entries, usedKeys, {
+            key: ruleKey,
+            group: 'rule',
+            summary: 'Framed technical surface contract: section-frame paints a clipped grid overlay and context-surface protects child content.',
+            tags: (0, utils_1.unique)([
+                'rule',
+                'ui',
+                'surface',
+                'framed-surface',
+                'section-frame',
+                'context-surface',
+                'grid-overlay',
+                'pseudo-element',
+                'nested-surface',
+                ...classes,
+            ]),
+            dependencies: contractDependencies(framedSurfaceFiles),
+            usedBy: [],
+            confidence: 'high',
+            status: 'inferred',
+            path: primary.relPath,
+            value: {
+                name: 'Section frame grid surface contract',
+                kind: 'rule',
+                ruleType: 'ui-framed-surface',
+                surfaceClasses: ['section-frame', 'context-surface'],
+                classes,
+                paintModel: {
+                    sectionFrame: 'section-frame is not only border/background; it owns the clipped section-frame::before grid overlay for that exact surface.',
+                    contextSurface: 'context-surface keeps direct children above the parent overlay, preserving readable content and separate child surfaces.',
+                },
+                nestingGuidance: [
+                    'For parent technical panels, use section-frame with context-surface when content or child cards must sit above the parent grid.',
+                    'Nested framed child surfaces need their own section-frame/context-surface pairing when the design expects each child to have an independent clipped grid origin.',
+                    'Do not rely on one ancestor section-frame grid for child cards that visually have separate framed grids in the source design.',
+                ],
+                usageGuidance: [
+                    'Use this contract for framed technical panels and code/context surfaces, not every ordinary repeated card.',
+                    'Preserve responsive forms such as sm:section-frame when the source intentionally keeps mobile surfaces transparent or unframed.',
+                ],
+                avoid: [
+                    'Do not add decorative glow/shadow classes to repeated cards just because they are framed.',
+                    'Do not flatten parent and child frame classes onto one root; preserve the surface hierarchy.',
+                ],
+                cssRules,
+                sourceHash: primary.sourceHash,
+                source: sourceInfo('ui.global-contracts', 'high', framedSurfaceFiles.slice(0, 20).map((file) => `path:${file.relPath}`), primary),
+            },
+        });
+        nodes.push(toGraphNode(ruleKey, 'rule', 'Section frame grid surface contract', primary.relPath, primary, 'ui.global-contracts', {
+            ui: {
+                ruleType: 'ui-framed-surface',
+                surfaceClasses: ['section-frame', 'context-surface'],
+                classes,
+            },
+        }));
+        for (const file of framedSurfaceFiles.slice(0, 80)) {
+            edges.push(toGraphEdge(file.key, ruleKey, 'defines_ui_contract', 'ui.global-contracts', file));
+            if (hasStyleSurface(file)) {
+                edges.push(toGraphEdge(styleKeyForFile(file), ruleKey, 'defines_ui_contract', 'ui.global-contracts', file));
+            }
+        }
+    }
+}
+function hasPageShellContractEvidence(file) {
+    return Boolean(file.classReferences.includes('app-shell') ||
+        file.cssClasses.includes('app-shell') ||
+        file.cssRules.some(shellCssRuleMatches) ||
+        (file.relPath.endsWith('layout.tsx') && file.classReferences.includes('bg-background')));
+}
+function hasFramedSurfaceContractEvidence(file) {
+    return Boolean(file.classReferences.some((className) => ['section-frame', 'sm:section-frame', 'context-surface'].includes(className)) ||
+        file.cssClasses.some((className) => ['section-frame', 'context-surface'].includes(className)) ||
+        file.cssRules.some(framedSurfaceCssRuleMatches));
+}
+function shellCssRuleMatches(rule) {
+    return /(^|[,\s])(?:html|body|:root)(?:$|[,\s:{.#])|\.app-shell\b|\.bg-background\b/.test(rule.selector);
+}
+function framedSurfaceCssRuleMatches(rule) {
+    return /\.section-frame\b|\.context-surface\b/.test(rule.selector);
+}
+function contractDependencies(files) {
+    return (0, utils_1.unique)(files.flatMap((file) => [file.key, ...(hasStyleSurface(file) ? [styleKeyForFile(file)] : [])]));
+}
+function styleKeyForFile(file) {
+    return (0, utils_1.toRegistryKey)('style', file.relPath.replace(/\.[^.]+$/, ''));
+}
+function collectClassEvidence(files, predicate) {
+    return (0, utils_1.unique)(files.flatMap((file) => [...file.classReferences, ...file.cssClasses].filter(predicate))).slice(0, 120);
+}
+function cssRuleSnapshots(files, predicate) {
+    return (0, utils_1.uniqueBy)(files.flatMap((file) => file.cssRules.filter(predicate).map((rule) => ({
+        path: file.relPath,
+        selector: rule.selector,
+        line: rule.line,
+        declarations: rule.declarations.slice(0, 24),
+    }))), (rule) => `${rule.path}:${rule.selector}:${rule.line}`);
+}
+function addConnectedPatternRules(entries, usedKeys, nodes, edges, reviewItems, files, styleContext) {
+    const clusters = buildConnectedPatternClusters(files, styleContext);
     for (const cluster of clusters) {
         addEntry(entries, usedKeys, {
             key: cluster.key,
@@ -967,9 +3542,9 @@ function addConnectedPatternRules(entries, usedKeys, nodes, edges, reviewItems,
         }
     }
 }
-function buildConnectedPatternClusters(files) {
+function buildConnectedPatternClusters(files, styleContext) {
     const instances = [
-        ...files.flatMap(createFrontendPatternInstances),
+        ...files.flatMap((file) => createFrontendPatternInstances(file, styleContext)),
         ...createBackendPatternInstances(files),
         ...createDataPatternInstances(files),
     ];
@@ -990,7 +3565,62 @@ function buildConnectedPatternClusters(files) {
         const classGroups = (0, extractors_1.mergeClassGroups)(group
             .map((instance) => instance.root?.classGroups)
             .filter((value) => Boolean(value)));
+        const layoutSafety = summarizeConnectedLayoutSafety(group);
+        const responsiveProfile = summarizeConnectedResponsiveProfile(group);
+        const scaleProfile = summarizeConnectedScaleProfile(group);
+        const semanticProfile = summarizeConnectedSemanticProfile(group);
+        const roleSignatures = summarizeConnectedRoleSignatures(group);
+        const roleSignature = roleSignatures[0];
+        const compoundStructure = summarizeConnectedCompoundStructure(group);
+        const parentContexts = summarizeConnectedParentContexts(group);
         const childStructure = summarizeConnectedChildren(group);
+        const graphKeys = (0, utils_1.unique)(group.flatMap((instance) => instance.graphKeys)).slice(0, 80);
+        const structureContract = {
+            preserveRootAndChildrenTogether: true,
+            preserveParentLayoutContext: Boolean(parentContexts.length),
+            preserveDirectChildRelationships: Boolean(childStructure.length),
+            preserveCompoundChildRoles: Boolean(compoundStructure),
+            preserveResponsiveBreakpoints: Boolean(responsiveProfile),
+            preserveLayoutSafety: Boolean(layoutSafety),
+            preserveScaleBounds: Boolean(scaleProfile),
+            preserveRoleSignature: Boolean(roleSignature),
+            avoidDefaultDecorativeAccents: Boolean(decorativeAccentClasses.length),
+        };
+        const uiContract = createUiPatternContract({
+            name: `${(0, utils_1.titleCase)(first.concept)} connected pattern`,
+            count: group.length,
+            kind: first.concept,
+            tag: first.root?.tag,
+            layoutRole: first.root?.layoutRole,
+            path: first.file.relPath,
+            sourceHash: first.file.sourceHash,
+            confidence,
+            evidence: first.evidence.label,
+            classes: defaultClasses,
+            defaultClasses,
+            conditionalClasses,
+            decorativeAccentClasses,
+            classGroups,
+            layoutSafety,
+            responsiveProfile,
+            scaleProfile,
+            semanticProfile,
+            roleSignature,
+            styleContext,
+        });
+        uiContract.safetyRules = omitEmptyRecord({
+            ...uiContract.safetyRules,
+            structureContract,
+        });
+        const relationships = createUiRelationships({
+            parentContext: parentContexts,
+            childStructureContract: {
+                children: childStructure,
+                preserveDirectChildRelationships: Boolean(childStructure.length),
+            },
+            compoundStructure,
+            graphKeys,
+        });
         const key = (0, utils_1.toRegistryKey)('cluster', `pattern.${first.domain}.${first.concept}.${connectedPatternSlug(first)}.${(0, utils_1.shortHash)(first.signature)}`);
         const fileCount = new Set(group.map((instance) => instance.file.relPath)).size;
         clusters.push({
@@ -1015,6 +3645,28 @@ function buildConnectedPatternClusters(files) {
                 ...group.flatMap((instance) => instance.tags).slice(0, 80),
                 ...defaultClasses.slice(0, 24),
                 ...(decorativeAccentClasses.length ? ['decorative-accent', 'highlight-only'] : []),
+                ...(layoutSafety
+                    ? ['layout-safety', ...layoutSafety.layoutSafetyClasses.slice(0, 24)]
+                    : []),
+                ...(responsiveProfile ? ['responsive-contract'] : []),
+                ...(scaleProfile ? ['scale-contract'] : []),
+                ...(semanticProfile?.isCompound
+                    ? ['compound-ui', 'compound-badge', ...semanticProfile.roles]
+                    : []),
+                ...(roleSignatures.length
+                    ? [
+                        'role-signature',
+                        ...roleSignatures.flatMap((signature) => [
+                            signature.role,
+                            signature.roleGroup,
+                            signature.scale,
+                            signature.density,
+                            signature.surface,
+                            signature.layout,
+                            ...signature.flags,
+                        ]),
+                    ]
+                    : []),
             ]),
             dependencies,
             value: {
@@ -1034,9 +3686,19 @@ function buildConnectedPatternClusters(files) {
                 conditionalClasses,
                 decorativeAccentClasses,
                 classGroups,
+                ...(layoutSafety ? { layoutSafety } : {}),
+                ...(responsiveProfile ? { responsiveProfile } : {}),
+                ...(scaleProfile ? { scaleProfile } : {}),
+                ...(semanticProfile ? { semanticProfile } : {}),
+                ...(roleSignatures.length ? { roleSignatures } : {}),
+                ...(parentContexts.length ? { parentContexts } : {}),
                 childStructure,
+                ...(compoundStructure ? { compoundStructure } : {}),
+                structureContract,
+                uiContract,
+                relationships,
                 examples,
-                graphKeys: (0, utils_1.unique)(group.flatMap((instance) => instance.graphKeys)).slice(0, 80),
+                graphKeys,
                 guidance: createConnectedPatternGuidance(first, group, decorativeAccentClasses),
                 variants: connectedPatternVariants(first.domain, group),
                 children: connectedPatternChildren(first.domain, first.concept, group, dependencies),
@@ -1080,8 +3742,11 @@ function buildConnectedPatternClusters(files) {
     }
     return clusters.sort((a, b) => b.score - a.score || a.key.localeCompare(b.key));
 }
-function createFrontendPatternInstances(file) {
+function createFrontendPatternInstances(file, styleContext) {
     const instances = [];
+    if ((0, extractors_1.isTestFile)(file.relPath)) {
+        return instances;
+    }
     for (const element of file.uiElements) {
         if (!isConnectedUiPatternRoot(element)) {
             continue;
@@ -1093,7 +3758,14 @@ function createFrontendPatternInstances(file) {
             ...(0, extractors_1.filterClasses)(element.classes, extractors_1.isDecorativeAccentClass),
         ]).slice(0, 60);
         const classGroups = (0, extractors_1.groupTailwindClasses)(defaultClasses.length ? defaultClasses : element.classes);
-        const children = normalizeConnectedChildren(element.childSummary ?? []);
+        const children = normalizeConnectedChildren(element.childSummary ?? [], styleContext);
+        const parentContext = summarizeParentContexts([element])[0];
+        const childStructureContract = element.childSummary?.length
+            ? summarizeElementChildContract(element.childSummary, styleContext)
+            : undefined;
+        const compoundStructure = element.semanticProfile?.isCompound
+            ? summarizeCompoundStructure([element], styleContext)
+            : undefined;
         const component = file.components[0];
         const route = file.routes[0];
         const graphKeys = (0, utils_1.unique)([
@@ -1110,10 +3782,44 @@ function createFrontendPatternInstances(file) {
             'frontend',
             element.kind,
             normalizeLayoutRole(element.layoutRole),
+            roleSignatureKey(element.roleSignature),
             normalizeTagForSignature(element),
             classSignature(defaultClasses),
             children.map((child) => child.signature).join('|'),
         ].join(';');
+        const uiContract = createUiContract({
+            kind: element.kind,
+            tag: element.originalTag,
+            layoutRole: element.layoutRole,
+            label: element.label,
+            line: element.line,
+            path: file.relPath,
+            sourceHash: file.sourceHash,
+            confidence: 'medium',
+            evidence: element.evidence,
+            classSource: element.classSource,
+            classes: element.classes,
+            defaultClasses,
+            conditionalClasses,
+            decorativeAccentClasses,
+            classGroups,
+            layoutSafety: element.layoutSafety,
+            responsiveProfile: element.responsiveProfile,
+            scaleProfile: element.scaleProfile,
+            semanticProfile: element.semanticProfile,
+            roleSignature: element.roleSignature,
+            variants: element.variants,
+            props: element.props,
+            styleHelper: element.styleHelper,
+            styleHelperVariants: element.styleHelperVariants,
+            styleContext,
+        });
+        const relationships = createUiRelationships({
+            parentContext,
+            childStructureContract,
+            compoundStructure,
+            graphKeys,
+        });
         instances.push({
             domain: 'frontend',
             concept: element.kind,
@@ -1129,6 +3835,12 @@ function createFrontendPatternInstances(file) {
                 conditionalClasses,
                 decorativeAccentClasses,
                 classGroups,
+                ...(element.layoutSafety ? { layoutSafety: element.layoutSafety } : {}),
+                ...(element.responsiveProfile ? { responsiveProfile: element.responsiveProfile } : {}),
+                ...(element.scaleProfile ? { scaleProfile: element.scaleProfile } : {}),
+                ...(element.semanticProfile ? { semanticProfile: element.semanticProfile } : {}),
+                ...(element.roleSignature ? { roleSignature: element.roleSignature } : {}),
+                uiContract,
             },
             children: children.map(withoutConnectedChildSignature),
             graphKeys,
@@ -1142,6 +3854,25 @@ function createFrontendPatternInstances(file) {
                 ...file.components,
                 ...file.routes,
                 ...Object.keys(classGroups),
+                ...(element.layoutSafety ? ['layout-safety'] : []),
+                ...(element.responsiveProfile ? ['responsive-contract'] : []),
+                ...(element.scaleProfile ? ['scale-contract'] : []),
+                ...(element.roleSignature
+                    ? [
+                        'role-signature',
+                        element.roleSignature.role,
+                        element.roleSignature.roleGroup,
+                        element.roleSignature.scale,
+                        element.roleSignature.density,
+                        element.roleSignature.surface,
+                        element.roleSignature.layout,
+                        ...element.roleSignature.flags,
+                        ...element.roleSignature.exactClassFacts.slice(0, 24),
+                    ]
+                    : []),
+                ...(element.semanticProfile?.isCompound
+                    ? ['compound-ui', 'compound-badge', ...element.semanticProfile.roles]
+                    : []),
             ]),
             evidence: {
                 path: file.relPath,
@@ -1160,8 +3891,18 @@ function createFrontendPatternInstances(file) {
                     conditionalClasses,
                     decorativeAccentClasses,
                     classGroups,
+                    ...(element.layoutSafety ? { layoutSafety: element.layoutSafety } : {}),
+                    ...(element.responsiveProfile ? { responsiveProfile: element.responsiveProfile } : {}),
+                    ...(element.scaleProfile ? { scaleProfile: element.scaleProfile } : {}),
+                    ...(element.semanticProfile ? { semanticProfile: element.semanticProfile } : {}),
+                    ...(element.roleSignature ? { roleSignature: element.roleSignature } : {}),
+                    uiContract,
                 },
                 children: children.map(withoutConnectedChildSignature),
+                ...(parentContext ? { parentContext } : {}),
+                ...(childStructureContract ? { childStructureContract } : {}),
+                ...(compoundStructure ? { compoundStructure } : {}),
+                relationships,
             },
             baseWeight: frontendPatternWeight(file, element, children.length, defaultClasses),
         });
@@ -1185,6 +3926,7 @@ function createBackendPatternInstances(files) {
             ...file.services.map((service) => (0, utils_1.toRegistryKey)('service', service)),
             ...file.modules.map((moduleName) => (0, utils_1.toRegistryKey)('module', moduleName)),
             ...file.models.map((model) => (0, utils_1.toRegistryKey)('model', model)),
+            ...file.databaseAccesses.flatMap(databaseAccessDependencies),
             ...file.routes.map((route) => (0, utils_1.toRegistryKey)('route', route)),
         ]);
         const signature = [
@@ -1195,7 +3937,7 @@ function createBackendPatternInstances(files) {
             `methods:${methodShapes.join(',') || 'none'}`,
             `controller:${Boolean(file.controllers.length)}`,
             `service:${Boolean(file.services.length)}`,
-            `model:${Boolean(file.models.length)}`,
+            `model:${Boolean(file.models.length || file.databaseAccesses.length)}`,
             `auth:${Boolean(file.authHints.length || file.middleware.length)}`,
             `events:${Boolean(file.events.length || file.jobs.length)}`,
             `calls:${Boolean(file.apiCalls.length)}`,
@@ -1234,6 +3976,7 @@ function createBackendPatternInstances(files) {
                     modules: file.modules,
                     routes: file.routes,
                     models: file.models,
+                    databaseAccesses: file.databaseAccesses,
                     apiCalls: file.apiCalls,
                     envVars: file.envVars,
                     authHints: file.authHints,
@@ -1258,12 +4001,19 @@ function createDataPatternInstances(files) {
     const instances = [];
     for (const file of files) {
         for (const model of file.models) {
-            const fields = file.modelFields[model] ?? [];
+            const databaseModel = file.databaseModels.find((candidate) => candidate.name === model);
+            const fields = databaseModel
+                ? databaseFieldShapeInputs(databaseModel)
+                : (file.modelFields[model] ?? []);
             const fieldShape = summarizeModelFieldShape(fields);
+            const accessGraphKeys = file.databaseAccesses
+                .filter((access) => access.model === model || access.table === databaseModel?.tableName)
+                .map((access) => (0, utils_1.toRegistryKey)('database', `access.${file.relPath.replace(/\.[^.]+$/, '')}.${access.line}.${access.operation}.${access.model ?? access.table ?? access.receiver ?? 'unknown'}`));
             const signature = [
                 'data',
-                'model',
-                detectFrameworkForFile(file) ?? file.language,
+                databaseModel?.kind ?? 'model',
+                databaseModel?.provider ?? detectFrameworkForFile(file) ?? file.language,
+                databaseModel?.tableName ?? 'no-table',
                 fieldShape.signature,
             ].join(';');
             instances.push({
@@ -1272,8 +4022,24 @@ function createDataPatternInstances(files) {
                 signature,
                 summary: `${model} data model shape in ${file.relPath}.`,
                 file,
-                graphKeys: (0, utils_1.unique)([file.key, (0, utils_1.toRegistryKey)('model', model)]),
-                tags: (0, utils_1.unique)(['data', 'model', 'schema', model, file.language, ...fieldShape.tags]),
+                graphKeys: (0, utils_1.unique)([
+                    file.key,
+                    (0, utils_1.toRegistryKey)('model', model),
+                    ...(hasDatabaseSurface(file)
+                        ? [(0, utils_1.toRegistryKey)('database', file.relPath.replace(/\.[^.]+$/, ''))]
+                        : []),
+                    ...accessGraphKeys,
+                ]),
+                tags: (0, utils_1.unique)([
+                    'data',
+                    'database',
+                    databaseModel?.kind ?? 'model',
+                    'schema',
+                    model,
+                    databaseModel?.tableName ?? '',
+                    databaseModel?.provider ?? file.language,
+                    ...fieldShape.tags,
+                ]),
                 evidence: {
                     path: file.relPath,
                     key: (0, utils_1.toRegistryKey)('model', model),
@@ -1281,18 +4047,35 @@ function createDataPatternInstances(files) {
                 },
                 value: {
                     model,
-                    fields,
+                    fields: databaseModel?.fieldNames ?? fields,
+                    fieldDetails: databaseModel?.fields ?? [],
                     fieldShape,
-                    framework: detectFrameworkForFile(file),
+                    tableName: databaseModel?.tableName,
+                    provider: databaseModel?.provider,
+                    primaryKey: databaseModel?.primaryKey ?? [],
+                    uniqueFields: databaseModel?.uniqueFields ?? [],
+                    indexes: databaseModel?.indexes ?? [],
+                    relations: databaseModel?.relations ?? [],
+                    enumRefs: databaseModel?.enumRefs ?? [],
+                    accesses: file.databaseAccesses.filter((access) => access.model === model || access.table === databaseModel?.tableName),
+                    framework: databaseModel?.framework ?? detectFrameworkForFile(file),
                 },
-                baseWeight: 3 + Math.min(fields.length / 2, 8),
+                baseWeight: 3 +
+                    Math.min(fields.length / 2, 8) +
+                    Math.min((databaseModel?.relations.length ?? 0) * 0.75, 4) +
+                    Math.min(accessGraphKeys.length * 0.5, 4),
             });
         }
     }
     return instances;
 }
 function isConnectedUiPatternRoot(element) {
-    if (element.kind === 'unknown' || element.kind === 'link' || element.kind === 'text') {
+    if (element.kind === 'unknown' ||
+        element.kind === 'link' ||
+        element.kind === 'text' ||
+        element.kind === 'icon' ||
+        element.kind === 'image' ||
+        element.kind === 'divider') {
         return false;
     }
     if (['button', 'input', 'badge'].includes(element.kind)) {
@@ -1300,9 +4083,12 @@ function isConnectedUiPatternRoot(element) {
     }
     return (0, extractors_1.isCompositionElement)(element) || Boolean(element.childSummary?.length);
 }
-function normalizeConnectedChildren(children) {
+function normalizeConnectedChildren(children, styleContext) {
     return children
-        .filter((child) => child.kind !== 'unknown' || child.classes.length || child.label)
+        .filter((child) => child.kind !== 'unknown' ||
+        child.classes.length ||
+        child.label ||
+        Boolean(child.semanticRole))
         .slice(0, 10)
         .map((child) => {
         const defaultClasses = (0, extractors_1.filterClasses)(child.defaultClasses?.length ? child.defaultClasses : child.classes, (className) => !(0, extractors_1.isDecorativeAccentClass)(className)).slice(0, 48);
@@ -1311,6 +4097,8 @@ function normalizeConnectedChildren(children) {
         const signature = [
             normalizedKind,
             normalizeLayoutRole(child.layoutRole),
+            child.semanticRole ?? 'unspecified-semantic-role',
+            roleSignatureKey(child.roleSignature),
             normalizeChildTagForSignature(child),
             classSignature(defaultClasses),
         ].join(':');
@@ -1320,8 +4108,17 @@ function normalizeConnectedChildren(children) {
             sourceKind: child.kind,
             tag: child.originalTag,
             layoutRole: child.layoutRole,
+            semanticRole: child.semanticRole,
+            uiContract: createUiContractForChild(child, styleContext),
             defaultClasses,
             conditionalClasses: child.conditionalClasses?.slice(0, 32) ?? [],
+            layoutSafety: child.layoutSafety,
+            responsiveProfile: child.responsiveProfile,
+            scaleProfile: child.scaleProfile,
+            roleSignature: child.roleSignature,
+            variants: child.variants ?? {},
+            styleHelper: child.styleHelper,
+            styleHelperVariants: child.styleHelperVariants ?? {},
             classGroups,
             labelHint: child.label ? labelSignature(child.label) : undefined,
         };
@@ -1331,25 +4128,125 @@ function withoutConnectedChildSignature(child) {
     return Object.fromEntries(Object.entries(child).filter(([key]) => key !== 'signature'));
 }
 function connectedChildKind(child) {
+    if (child.semanticRole === 'icon' || child.semanticRole === 'component-icon') {
+        return 'icon';
+    }
+    if (child.semanticRole === 'image') {
+        return 'image';
+    }
+    if (child.semanticRole === 'divider') {
+        return 'divider';
+    }
     if (child.layoutRole === 'eyebrow-or-badge') {
         return 'badge';
     }
     return child.kind;
 }
+function isRecordValue(value) {
+    return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+function isRoleSignatureRecord(value) {
+    return (isRecordValue(value) &&
+        typeof value.role === 'string' &&
+        typeof value.roleGroup === 'string' &&
+        typeof value.scale === 'string' &&
+        typeof value.density === 'string' &&
+        typeof value.surface === 'string' &&
+        typeof value.layout === 'string' &&
+        Array.isArray(value.flags) &&
+        Array.isArray(value.exactClassFacts));
+}
+function summarizeConnectedLayoutSafety(instances) {
+    return mergeLayoutSafetyProfiles([
+        ...instances.map((instance) => ({ layoutSafety: instance.root?.layoutSafety })),
+        ...instances.flatMap((instance) => (instance.children ?? []).map((child) => ({
+            layoutSafety: isLayoutSafetyProfile(child.layoutSafety) ? child.layoutSafety : undefined,
+        }))),
+    ]);
+}
+function summarizeConnectedResponsiveProfile(instances) {
+    return mergeResponsiveProfiles([
+        ...instances.map((instance) => ({ responsiveProfile: instance.root?.responsiveProfile })),
+        ...instances.flatMap((instance) => (instance.children ?? []).map((child) => ({
+            responsiveProfile: isResponsiveProfile(child.responsiveProfile)
+                ? child.responsiveProfile
+                : undefined,
+        }))),
+    ]);
+}
+function summarizeConnectedScaleProfile(instances) {
+    return mergeScaleProfiles([
+        ...instances.map((instance) => ({ scaleProfile: instance.root?.scaleProfile })),
+        ...instances.flatMap((instance) => (instance.children ?? []).map((child) => ({
+            scaleProfile: isScaleProfile(child.scaleProfile) ? child.scaleProfile : undefined,
+        }))),
+    ]);
+}
+function summarizeConnectedSemanticProfile(instances) {
+    return mergeSemanticProfiles(instances.map((instance) => ({ semanticProfile: instance.root?.semanticProfile })));
+}
+function summarizeConnectedRoleSignatures(instances) {
+    return (0, utils_1.uniqueBy)(instances
+        .map((instance) => instance.root?.roleSignature)
+        .filter((value) => Boolean(value)), (signature) => roleSignatureKey(signature)).slice(0, 12);
+}
+function summarizeConnectedCompoundStructure(instances) {
+    const compoundInstances = instances.filter((instance) => instance.root?.semanticProfile?.isCompound);
+    if (!compoundInstances.length) {
+        return undefined;
+    }
+    const childCounts = compoundInstances.map((instance) => instance.children?.length ?? 0);
+    const childOrderExamples = (0, utils_1.uniqueBy)(compoundInstances
+        .map((instance) => instance.value.childStructureContract)
+        .filter((value) => isRecordValue(value)), (value) => JSON.stringify(value)).slice(0, 8);
+    const semanticProfile = summarizeConnectedSemanticProfile(compoundInstances);
+    return {
+        preserveCompoundChildren: true,
+        preserveIconAndDividerRoles: Boolean(semanticProfile?.hasIcon || semanticProfile?.hasDivider),
+        preserveMultipleTextSegments: Boolean(semanticProfile?.hasMultipleTextStyles),
+        directChildCountRange: {
+            min: Math.min(...childCounts),
+            max: Math.max(...childCounts),
+        },
+        semanticRoles: semanticProfile?.roles ?? [],
+        childOrderExamples,
+    };
+}
+function summarizeConnectedParentContexts(instances) {
+    return (0, utils_1.uniqueBy)(instances
+        .map((instance) => instance.value.parentContext)
+        .filter((value) => isRecordValue(value)), (context) => JSON.stringify(context)).slice(0, 12);
+}
 function summarizeConnectedChildren(instances) {
     const childValues = instances.flatMap((instance) => instance.children ?? []);
     const grouped = (0, utils_1.groupBy)(childValues, (child) => [
         String(child.kind ?? ''),
         String(child.layoutRole ?? ''),
+        String(child.semanticRole ?? ''),
+        roleSignatureKey(isRoleSignatureRecord(child.roleSignature) ? child.roleSignature : undefined),
         JSON.stringify(child.classGroups ?? {}),
     ].join(':'));
     return Array.from(grouped.values())
         .map((children) => {
         const first = children[0] ?? {};
+        const layoutSafety = mergeLayoutSafetyProfiles(children.map((child) => ({
+            layoutSafety: isLayoutSafetyProfile(child.layoutSafety) ? child.layoutSafety : undefined,
+        })));
+        const responsiveProfile = mergeResponsiveProfiles(children.map((child) => ({
+            responsiveProfile: isResponsiveProfile(child.responsiveProfile)
+                ? child.responsiveProfile
+                : undefined,
+        })));
+        const scaleProfile = mergeScaleProfiles(children.map((child) => ({
+            scaleProfile: isScaleProfile(child.scaleProfile) ? child.scaleProfile : undefined,
+        })));
         return {
             kind: first.kind,
             tag: first.tag,
             layoutRole: first.layoutRole,
+            semanticRole: first.semanticRole,
+            roleSignature: first.roleSignature,
+            uiContract: first.uiContract,
             count: children.length,
             defaultClasses: (0, utils_1.unique)(children.flatMap((child) => Array.isArray(child.defaultClasses)
                 ? child.defaultClasses.filter((item) => typeof item === 'string')
@@ -1357,11 +4254,29 @@ function summarizeConnectedChildren(instances) {
             classGroups: (0, extractors_1.mergeClassGroups)(children
                 .map((child) => child.classGroups)
                 .filter((value) => Boolean(value))),
+            ...(layoutSafety ? { layoutSafety } : {}),
+            ...(responsiveProfile ? { responsiveProfile } : {}),
+            ...(scaleProfile ? { scaleProfile } : {}),
+            variants: mergeChildVariants(children),
+            styleHelpers: (0, utils_1.unique)(children
+                .map((child) => child.styleHelper)
+                .filter((value) => typeof value === 'string' && Boolean(value))).slice(0, 12),
         };
     })
         .sort((a, b) => Number(b.count) - Number(a.count))
         .slice(0, 16);
 }
+function mergeChildVariants(children) {
+    const variants = children
+        .map((child) => child.variants)
+        .filter((value) => {
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+            return false;
+        }
+        return Object.values(value).every((item) => typeof item === 'string');
+    });
+    return (0, extractors_1.mergeVariantProps)(variants);
+}
 function compactConnectedPatternInstance(instance) {
     return {
         path: instance.file.relPath,
@@ -1548,7 +4463,9 @@ function createConceptPatternDecision(name, scores, shouldReview, roleCandidateC
 function connectedPatternVariants(domain, instances) {
     const preferredPrefixes = domain === 'frontend'
         ? ['component.', 'route.', 'style.', 'rule.']
-        : ['api.', 'controller.', 'service.', 'module.', 'model.', 'route.'];
+        : domain === 'data'
+            ? ['database.', 'model.', 'service.', 'api.', 'route.']
+            : ['api.', 'controller.', 'service.', 'module.', 'model.', 'route.'];
     return (0, utils_1.unique)(instances.flatMap((instance) => [
         ...instance.file.components.map((component) => (0, utils_1.toRegistryKey)('component', component)),
         ...instance.file.routes.map((route) => (0, utils_1.toRegistryKey)('route', route)),
@@ -1557,6 +4474,9 @@ function connectedPatternVariants(domain, instances) {
         ...instance.file.services.map((service) => (0, utils_1.toRegistryKey)('service', service)),
         ...instance.file.modules.map((moduleName) => (0, utils_1.toRegistryKey)('module', moduleName)),
         ...instance.file.models.map((model) => (0, utils_1.toRegistryKey)('model', model)),
+        ...(hasDatabaseSurface(instance.file)
+            ? [(0, utils_1.toRegistryKey)('database', instance.file.relPath.replace(/\.[^.]+$/, ''))]
+            : []),
         ...instance.graphKeys.filter((key) => preferredPrefixes.some((prefix) => key.startsWith(prefix))),
     ])).slice(0, 80);
 }
@@ -1572,6 +4492,9 @@ function connectedPatternChildren(domain, concept, instances, dependencies) {
         const graphChildren = dependencies.filter((key) => ['component.', 'style.', 'rule.', 'route.'].some((prefix) => key.startsWith(prefix)));
         return (0, utils_1.unique)([...semanticChildren, ...graphChildren]).slice(0, 80);
     }
+    if (domain === 'data') {
+        return (0, utils_1.unique)(dependencies.filter((key) => ['database.', 'model.', 'service.', 'api.', 'route.', 'file.'].some((prefix) => key.startsWith(prefix)))).slice(0, 80);
+    }
     return (0, utils_1.unique)(dependencies.filter((key) => ['api.', 'controller.', 'service.', 'module.', 'model.', 'route.', 'file.'].some((prefix) => key.startsWith(prefix)))).slice(0, 80);
 }
 function derivePatternOwners(filePaths) {
@@ -1635,6 +4558,7 @@ function backendPatternWeight(file) {
         file.controllers.length * 2 +
         file.services.length * 2 +
         file.models.length * 1.5 +
+        file.databaseAccesses.length * 1.2 +
         file.authHints.length * 0.5 +
         file.events.length * 0.5 +
         file.jobs.length * 0.5);
@@ -1644,6 +4568,7 @@ function hasBackendPatternSurface(file) {
         file.controllers.length ||
         file.services.length ||
         file.modules.length ||
+        file.databaseAccesses.length ||
         file.apiCalls.length ||
         file.middleware.length ||
         file.jobs.length ||
@@ -1651,13 +4576,17 @@ function hasBackendPatternSurface(file) {
 }
 function backendPatternConcept(file) {
     if (file.controllers.length) {
-        return file.services.length || file.models.length ? 'api-controller-flow' : 'api-controller';
+        return file.services.length || file.models.length || file.databaseAccesses.length
+            ? 'api-controller-flow'
+            : 'api-controller';
     }
     if (file.apiHandlers.length) {
-        return file.models.length || file.authHints.length ? 'api-data-flow' : 'api-route';
+        return file.models.length || file.databaseAccesses.length || file.authHints.length
+            ? 'api-data-flow'
+            : 'api-route';
     }
     if (file.services.length) {
-        return file.models.length ? 'service-data-flow' : 'service';
+        return file.models.length || file.databaseAccesses.length ? 'service-data-flow' : 'service';
     }
     if (file.jobs.length || file.events.length) {
         return 'async-flow';
@@ -1667,6 +4596,22 @@ function backendPatternConcept(file) {
     }
     return 'backend-flow';
 }
+function databaseFieldShapeInputs(model) {
+    return model.fields.map((field) => [
+        field.name,
+        field.type ?? '',
+        field.id ? '@id' : '',
+        field.unique ? '@unique' : '',
+        field.optional ? '?' : '',
+        field.list ? '[]' : '',
+        field.default ? `default:${field.default}` : '',
+        field.enumName ? `enum:${field.enumName}` : '',
+        field.relation ? '@relation' : '',
+        field.relation?.onDelete ? `onDelete:${field.relation.onDelete}` : '',
+    ]
+        .filter(Boolean)
+        .join(' '));
+}
 function summarizeModelFieldShape(fields) {
     const counts = {
         id: 0,
@@ -1718,7 +4663,25 @@ function createConnectedPatternGuidance(first, instances, decorativeAccentClasse
         `Pattern score is based on usage count, file spread, component/route evidence, and structural specificity.`,
     ];
     if (first.domain === 'frontend') {
-        guidance.push('Use defaultClasses for normal generation. Use childStructure to keep spacing, hierarchy, and slots aligned with the source pattern.');
+        guidance.push('Use defaultClasses for normal generation. Use childStructure to keep spacing, hierarchy, and slots aligned with the source pattern.', 'Use structureContract, parentContexts, layoutSafety, responsiveProfile, and scaleProfile as hard generation constraints before adding any new visual detail.');
+        if (summarizeConnectedLayoutSafety(instances)) {
+            guidance.push('Preserve layoutSafety classes with their original element. They prevent wrapped buttons, overflowing card text, collapsed columns, and mobile clipping.');
+        }
+        if (summarizeConnectedParentContexts(instances).length) {
+            guidance.push('Preserve parentContexts when placing this pattern. Repeated cards and nested panels should inherit the same grid/flex parent relationship as the source.');
+        }
+        if (summarizeConnectedScaleProfile(instances)) {
+            guidance.push('Preserve scaleProfile for typography, spacing, max-width, and line-height. Do not make headings or section spacing larger than observed source bounds.');
+        }
+        if (summarizeConnectedRoleSignatures(instances).length) {
+            guidance.push('Preserve roleSignature and roleConstraints as hard constraints. Lookalike patterns with different role, density, surface, layout, or exactClassFacts are different generation targets.');
+        }
+        if (summarizeConnectedResponsiveProfile(instances)) {
+            guidance.push('Preserve responsiveProfile exactly enough that mobile and desktop layouts use the same breakpoints and visibility behavior as the source.');
+        }
+        if (summarizeConnectedCompoundStructure(instances)) {
+            guidance.push('For compound badges, hero eyebrows, and brand chips, preserve compoundStructure: icon/image children, divider children, multiple text segments, child order, compact spacing, and separate text styles. Do not collapse the lockup into a single text-only pill.');
+        }
     }
     if (decorativeAccentClasses.length) {
         guidance.push('decorativeAccentClasses are opt-in highlight treatments. They must not become default card/surface styling.');
@@ -1737,6 +4700,7 @@ function createConnectedPatternGuidance(first, instances, decorativeAccentClasse
 function connectedPatternSlug(instance) {
     const parts = [
         instance.concept,
+        instance.root?.roleSignature?.role,
         instance.root?.layoutRole,
         instance.root?.tag,
         ...Object.keys(instance.root?.classGroups ?? {}).slice(0, 3),
@@ -1751,6 +4715,22 @@ function connectedPatternSlug(instance) {
         .slice(0, 5)
         .join('.') || instance.concept);
 }
+function roleSignatureKey(signature) {
+    if (!signature) {
+        return 'role-signature:unspecified';
+    }
+    return [
+        signature.role,
+        signature.roleGroup,
+        signature.scale,
+        signature.density,
+        signature.surface,
+        signature.layout,
+        signature.flags.join(','),
+    ]
+        .filter(Boolean)
+        .join('|');
+}
 function classSignature(classes) {
     if (!classes.length) {
         return 'no-classes';
@@ -1771,7 +4751,7 @@ function normalizeTagForSignature(element) {
     return element.originalTag.toLowerCase();
 }
 function normalizeChildTagForSignature(child) {
-    if (['button', 'input', 'badge', 'heading', 'text', 'link'].includes(child.kind)) {
+    if (['button', 'input', 'badge', 'heading', 'text', 'link', 'icon', 'image', 'divider'].includes(child.kind)) {
         return child.kind;
     }
     return child.originalTag.toLowerCase();
@@ -1840,6 +4820,30 @@ function addStyleUsageEdges(entries, files, edges) {
         }
     }
 }
+function addDatabaseUsageEdges(entries, files, edges) {
+    const modelEntries = entries.filter((entry) => entry.group === 'model');
+    const modelKeysByName = new Map();
+    for (const entry of modelEntries) {
+        const name = typeof entry.value.name === 'string' ? entry.value.name : '';
+        const tableName = typeof entry.value.tableName === 'string' ? entry.value.tableName : '';
+        if (name) {
+            modelKeysByName.set(name.toLowerCase(), entry.key);
+        }
+        if (tableName) {
+            modelKeysByName.set(tableName.toLowerCase(), entry.key);
+        }
+    }
+    for (const file of files) {
+        for (const access of file.databaseAccesses) {
+            const targetName = access.model ?? access.table;
+            const targetKey = targetName ? modelKeysByName.get(targetName.toLowerCase()) : undefined;
+            if (!targetKey) {
+                continue;
+            }
+            edges.push(toGraphEdge(file.key, targetKey, databaseAccessEdgeType(access), `database.${access.framework}.access`, file, access.confidence));
+        }
+    }
+}
 function addModelUsageEdges(entries, files, edges) {
     const modelEntries = entries.filter((entry) => entry.group === 'model');
     for (const file of files) {
@@ -1870,6 +4874,50 @@ function addModelUsageEdges(entries, files, edges) {
         }
     }
 }
+function addDatabaseReviewItems(entries, reviewItems) {
+    const modelEntries = entries.filter((entry) => entry.group === 'model');
+    const byName = (0, utils_1.groupBy)(modelEntries, (entry) => String(entry.value.name ?? entry.key).toLowerCase());
+    for (const [name, candidates] of byName) {
+        if (candidates.length < 2) {
+            continue;
+        }
+        const signatures = (0, utils_1.unique)(candidates.map((candidate) => {
+            const fields = Array.isArray(candidate.value.fields)
+                ? candidate.value.fields.map(String).sort()
+                : [];
+            const provider = String(candidate.value.provider ?? '');
+            const tableName = String(candidate.value.tableName ?? '');
+            return `${provider}:${tableName}:${fields.join('|')}`;
+        }));
+        if (signatures.length <= 1) {
+            continue;
+        }
+        reviewItems.push({
+            id: `review.data.model.${name}.conflict`,
+            type: 'concept_collision',
+            status: 'open',
+            group: 'model',
+            s: `Multiple ${name} data model shapes were found. Confirm the canonical model/table before broad generation.`,
+            candidates: candidates.map((candidate) => candidate.key).slice(0, 40),
+        });
+    }
+    const riskyAccessCandidates = entries
+        .filter((entry) => entry.group === 'database' &&
+        entry.value.kind === 'database-access' &&
+        Array.isArray(entry.value.risk) &&
+        entry.value.risk.includes('manual-review'))
+        .map((entry) => entry.key);
+    if (riskyAccessCandidates.length) {
+        reviewItems.push({
+            id: 'review.data.access.manual-review',
+            type: 'low_confidence',
+            status: 'open',
+            group: 'database',
+            s: 'Raw SQL or high-risk database accesses were found. Review before using them as broad generation patterns.',
+            candidates: riskyAccessCandidates.slice(0, 40),
+        });
+    }
+}
 function addConceptClusters(entries, usedKeys, nodes, edges, reviewItems) {
     const concepts = [
         {
@@ -2082,9 +5130,25 @@ function detectProjectFacts(files) {
     }
     if (dependencies.has('prisma') ||
         dependencies.has('@prisma/client') ||
-        files.some((file) => file.models.length)) {
+        files.some((file) => file.databaseModels.some((model) => model.provider === 'prisma'))) {
         frameworks.add('prisma');
     }
+    if (dependencies.has('drizzle-orm') ||
+        files.some((file) => file.databaseModels.some((model) => model.provider === 'drizzle'))) {
+        frameworks.add('drizzle');
+    }
+    if (dependencies.has('typeorm') ||
+        files.some((file) => file.databaseModels.some((model) => model.provider === 'typeorm'))) {
+        frameworks.add('typeorm');
+    }
+    if (dependencies.has('sequelize') ||
+        files.some((file) => file.databaseModels.some((model) => model.provider === 'sequelize'))) {
+        frameworks.add('sequelize');
+    }
+    if (dependencies.has('mongoose') ||
+        files.some((file) => file.databaseModels.some((model) => model.provider === 'mongoose'))) {
+        frameworks.add('mongoose');
+    }
     if (files.some((file) => file.language === 'css' || file.language === 'scss')) {
         frameworks.add('css');
     }
@@ -2119,7 +5183,9 @@ function detectProjectFacts(files) {
     if (files.some((file) => file.language === 'go')) {
         frameworks.add('go');
     }
-    if (files.some((file) => file.language === 'sql')) {
+    if (files.some((file) => file.language === 'sql' ||
+        file.databaseModels.some((model) => model.provider === 'sql') ||
+        file.databaseMigrations.some((migration) => migration.provider === 'sql'))) {
         frameworks.add('sql');
     }
     return {
@@ -2137,8 +5203,10 @@ function detectFrameworkForFile(file) {
     if (file.controllers.length || file.services.length || file.modules.length) {
         return 'nestjs';
     }
-    if (file.models.length) {
-        return 'prisma';
+    if (file.databaseModels.length || file.databaseEnums.length || file.databaseMigrations.length) {
+        return (file.databaseModels[0]?.provider ??
+            file.databaseEnums[0]?.provider ??
+            file.databaseMigrations[0]?.provider);
     }
     if (file.kind.includes('style') || file.kind.includes('css')) {
         return 'css';