@odavl/guardian 0.1.0-rc1 → 1.0.0

package/src/guardian/semantic-contact-finder.js

@@ -0,0 +1,201 @@
+/**
+ * Semantic Contact Finder Integration
+ * 
+ * Integrates semantic contact detection into the scanning flow.
+ * Works with Playwright to find contact links/forms in real pages.
+ * 
+ * Now includes Wave 1.2 detection layers with data-guardian attribute support.
+ */
+
+const { detectLanguage, getPrimaryLanguage, getLanguageName } = require('./language-detection');
+const { detectContactCandidates, formatDetectionResult, getNoContactFoundHint } = require('./semantic-contact-detection');
+const { getTokensForTarget, normalizeText } = require('./semantic-targets');
+const { detectByLayers, LAYER, CONFIDENCE } = require('./detection-layers');
+
+/**
+ * Find contact elements on a page using semantic detection
+ * 
+ * @param {Page} page - Playwright page object
+ * @param {string} baseUrl - Base URL for relative links
+ * @returns {Promise<Object>} Detection result with language, candidates, and recommendations
+ */
+async function findContactOnPage(page, baseUrl = '') {
+  const result = {
+    language: 'unknown',
+    languageName: 'Unknown',
+    candidates: [],
+    found: false,
+    hint: ''
+  };
+
+  try {
+    // Detect language
+    result.language = await detectLanguage(page);
+    result.languageName = getLanguageName(result.language);
+
+    // Find contact candidates
+    const candidates = await detectContactCandidates(page, baseUrl);
+    result.candidates = candidates;
+
+    if (candidates.length > 0) {
+      result.found = true;
+      result.primaryCandidate = candidates[0]; // Highest confidence
+    } else {
+      result.hint = getNoContactFoundHint();
+    }
+
+    return result;
+  } catch (error) {
+    console.warn(`Contact detection failed: ${error.message}`);
+    result.hint = `Contact detection failed: ${error.message}. Fallback to default selectors.`;
+    return result;
+  }
+}
+
+/**
+ * Generate Playwright selectors from semantic candidates
+ * Returns a fallback selector chain compatible with attempt registry
+ */
+function generateSelectorsFromCandidates(candidates) {
+  if (!candidates || candidates.length === 0) {
+    return null;
+  }
+
+  // Take top 3 candidates, prefer high confidence
+  const topCandidates = candidates.slice(0, 3);
+
+  // Build selector chain
+  const selectors = topCandidates
+    .map(c => c.selector)
+    .filter(Boolean)
+    .join(', ');
+
+  return selectors || null;
+}
+
+/**
+ * Find contact elements using Wave 1.2 detection layers
+ * Respects priority: data-guardian > href > text > structure
+ * 
+ * @param {Page} page - Playwright page object
+ * @param {string} target - Detection target (contact, form, submit, about)
+ * @param {string} baseUrl - Base URL for relative links
+ * @returns {Promise<Object>} Detection result with layer, confidence, reason
+ */
+async function findElementByLayers(page, target, baseUrl = '') {
+  const result = {
+    language: 'unknown',
+    languageName: 'Unknown',
+    target: target,
+    found: false,
+    layer: null,
+    confidence: null,
+    candidates: [],
+    primaryCandidate: null,
+    reason: '',
+    hint: ''
+  };
+
+  try {
+    // Detect language
+    result.language = await detectLanguage(page);
+    result.languageName = getLanguageName(result.language);
+
+    // Use Wave 1.2 detection layers
+    const layerResult = await detectByLayers(page, target, baseUrl);
+
+    result.found = layerResult.found;
+    result.layer = layerResult.layer;
+    result.confidence = layerResult.confidence;
+    result.candidates = layerResult.candidates;
+    result.primaryCandidate = layerResult.primaryCandidate;
+    result.evidence = layerResult.evidence;
+    result.reason = layerResult.reason;
+
+    if (!result.found) {
+      result.hint = `No ${target} detected. Consider adding data-guardian="${target}" attribute for guaranteed stability.`;
+    }
+
+    return result;
+  } catch (error) {
+    console.warn(`Detection by layers failed: ${error.message}`);
+    result.reason = `Detection error: ${error.message}`;
+    result.hint = 'Fallback to manual configuration or heuristic detection.';
+    return result;
+  }
+}
+
+/**
+ * Generate Playwright selectors from semantic candidates
+ * Returns a fallback selector chain compatible with attempt registry
+ */
+function generateSelectorsFromCandidates(candidates) {
+  if (!candidates || candidates.length === 0) {
+    return null;
+  }
+
+  // Take top 3 candidates, prefer high confidence
+  const topCandidates = candidates.slice(0, 3);
+
+  // Build selector chain
+  const selectors = topCandidates
+    .map(c => c.selector)
+    .filter(Boolean)
+    .join(', ');
+
+  return selectors || null;
+}
+
+/**
+ * Format detection output for CLI reporting (Wave 1.2 enhanced)
+ * Shows which layer was used and how to improve stability
+ */
+function formatDetectionForReport(detectionResult) {
+  const lines = [];
+
+  lines.push(`🌍 Language Detection: ${detectionResult.languageName}`);
+  lines.push(`   (lang=${detectionResult.language})`);
+
+  if (detectionResult.found && detectionResult.candidates.length > 0) {
+    lines.push('');
+    
+    // Show detection layer (Wave 1.2)
+    if (detectionResult.layer) {
+      lines.push(`📍 Detection Layer: ${detectionResult.layer} (confidence: ${detectionResult.confidence})`);
+      lines.push(`   ${detectionResult.reason}`);
+      lines.push('');
+    }
+
+    lines.push(`✅ ${detectionResult.target} Detection Results (${detectionResult.candidates.length} candidate${detectionResult.candidates.length > 1 ? 's' : ''})`);
+
+    detectionResult.candidates.forEach((candidate, idx) => {
+      const formatted = formatDetectionResult(candidate, detectionResult.language);
+      lines.push(`   ${idx + 1}. ${formatted}`);
+      if (candidate.matchedText) {
+        lines.push(`      Text: "${candidate.matchedText}"`);
+      }
+      if (candidate.href) {
+        lines.push(`      Link: ${candidate.href}`);
+      }
+    });
+  } else {
+    lines.push('');
+    // Clarify selector-based scope to avoid overstating discovery
+    lines.push(`❌ No ${detectionResult.target || 'contact'} page/link discovered via selectors`);
+    if (detectionResult.reason) {
+      lines.push(`   Reason: ${detectionResult.reason}`);
+    }
+    if (detectionResult.hint) {
+      lines.push(`   💡 ${detectionResult.hint}`);
+    }
+  }
+
+  return lines.join('\n');
+}
+
+module.exports = {
+  findContactOnPage,
+  findElementByLayers,
+  generateSelectorsFromCandidates,
+  formatDetectionForReport
+};

package/src/guardian/semantic-targets.js

@@ -0,0 +1,234 @@
+/**
+ * Semantic Targets & Multilingual Dictionary
+ * 
+ * Provides deterministic, language-independent detection of semantic targets
+ * (contact, about, etc.) using normalized tokens from multiple languages.
+ */
+
+/**
+ * Multilingual dictionary for semantic targets
+ * Keys: target names, Values: arrays of normalized token variants
+ */
+const SEMANTIC_DICTIONARY = {
+  contact: [
+    // English
+    'contact', 'contactus', 'contact-us', 'contact us', 'get in touch', 'getintouch',
+    'reach out', 'reachout', 'contact form', 'contactform', 'contact page', 'contactpage',
+    'inquiry', 'inquiries', 'message us', 'messageus', 'write to us', 'writetus',
+    // German
+    'kontakt', 'kontaktieren', 'kontaktaufnahme', 'kontaktformular', 'kontakten',
+    'kontakts', 'kontakt formular', 'kontakt-formular', 'anfrage', 'anfragen',
+    // Spanish
+    'contacto', 'contactanos', 'contacta', 'formulario de contacto',
+    'pongase en contacto', 'ponte en contacto', 'escribenos', 'escriba',
+    // French
+    'contact', 'contactez', 'contactez-nous', 'formulaire de contact',
+    'nous contacter', 'nous ecrire',
+    // Portuguese
+    'contato', 'contacto', 'formulario de contato', 'entre em contato',
+    'fale conosco', 'escreva para nos',
+    // Italian
+    'contatti', 'contatto', 'contattaci', 'modulo di contatto',
+    'modulo contatti', 'mettersi in contatto',
+    // Dutch
+    'contact', 'contacteer', 'contact opnemen', 'contactformulier',
+    // Swedish
+    'kontakt', 'kontakta', 'kontaktformular',
+    // Arabic
+    'تواصل', 'اتصل', 'استفسار', 'استفسارات', 'نموذج الاتصال', 'نموذج تواصل',
+    // Chinese
+    '联系', '联系我们', '联系表单', '留言', '反馈'
+  ],
+  about: [
+    // English
+    'about', 'about us', 'aboutus', 'our story', 'about-us',
+    'company', 'team', 'who we are', 'whoweare', 'more about us',
+    // German
+    'uber', 'über', 'ueber', 'uber uns', 'über uns', 'ueber uns',
+    'uber unsere', 'über unsere', 'ueber unsere', 'team', 'unternehmen',
+    // Spanish
+    'acerca', 'acerca de', 'acerca de nosotros', 'sobre nosotros',
+    'quienes somos', 'quiénes somos', 'nuestra empresa',
+    // French
+    'a propos', 'à propos', 'a propos de nous', 'à propos de nous',
+    'qui sommes nous', 'qui nous sommes', 'notre histoire',
+    // Portuguese
+    'sobre', 'sobre nos', 'sobre nós', 'quem somos',
+    // Italian
+    'chi siamo', 'chi siamo noi', 'la nostra storia',
+    // Dutch
+    'over', 'over ons', 'wie zijn we',
+    // Swedish
+    'om', 'om oss', 'var historia',
+    // Arabic
+    'عن', 'عننا', 'عن الشركة', 'فريقنا', 'قصتنا'
+  ],
+  form: [
+    // English
+    'form', 'form submission', 'contact form', 'feedback form', 'inquiry form',
+    'form page', 'form element', 'form section', 'form area',
+    // German
+    'formular', 'form', 'kontaktformular', 'feedback formular',
+    // Spanish
+    'formulario', 'formulario de contacto', 'formulario de envio',
+    // French
+    'formulaire', 'formulaire de contact', 'formulaire d envoi',
+    // Portuguese
+    'formulario', 'formulario de contato', 'formulario de envio',
+    // Italian
+    'modulo', 'modulo di contatto', 'modulo di invio',
+    // Dutch
+    'formulier', 'contactformulier', 'formulier voor contact',
+    // Swedish
+    'formular', 'kontaktformular', 'feedback formular'
+  ],
+  submit: [
+    // English
+    'submit', 'send', 'send message', 'send form', 'submit form',
+    'submit button', 'send button', 'post', 'publish', 'share',
+    // German
+    'senden', 'absenden', 'abschicken', 'submit', 'ubermitteln',
+    // Spanish
+    'enviar', 'enviar formulario', 'enviar mensaje', 'publicar',
+    // French
+    'envoyer', 'soumettre', 'publier', 'partager',
+    // Portuguese
+    'enviar', 'enviar formulario', 'enviar mensagem', 'publicar',
+    // Italian
+    'inviare', 'inviare modulo', 'inviare messaggio', 'pubblicare',
+    // Dutch
+    'verzenden', 'verstuur', 'verstuur formulier', 'publiceren',
+    // Swedish
+    'skicka', 'skicka formular', 'publicera'
+  ]
+};
+
+/**
+ * Normalize text for comparison
+ * - Lowercase
+ * - Trim whitespace
+ * - Remove diacritics (é → e, ü → u, etc.)
+ * - Remove punctuation
+ * - Collapse multiple spaces
+ */
+function normalizeText(text) {
+  if (typeof text !== 'string') {
+    return '';
+  }
+
+  // Lowercase
+  let normalized = text.toLowerCase();
+
+  // Remove diacritics using Unicode normalization
+  // NFD: decompose accented characters, then filter combining marks
+  normalized = normalized
+    .normalize('NFD')
+    .replace(/[\u0300-\u036f]/g, '');
+
+  // Remove punctuation and special characters, keep spaces
+  normalized = normalized.replace(/[^\w\s]/g, ' ');
+
+  // Collapse multiple spaces
+  normalized = normalized.replace(/\s+/g, ' ').trim();
+
+  return normalized;
+}
+
+/**
+ * Check if normalized text includes any token from the list
+ * Matches whole words/tokens at word boundaries where appropriate
+ */
+function includesAnyToken(normalizedText, tokenList) {
+  if (!normalizedText || !Array.isArray(tokenList)) {
+    return false;
+  }
+
+  // Check each token
+  for (const token of tokenList) {
+    // Normalize the token
+    const normalizedToken = normalizeText(token);
+
+    if (!normalizedToken) {
+      continue;
+    }
+
+    // For very short tokens (<=4 chars), require word boundary
+    // For longer tokens (>4 chars), allow substring matching
+    if (normalizedToken.length <= 4) {
+      // Word boundary match
+      const wordBoundaryRegex = new RegExp(`\\b${normalizedToken}\\b`);
+      if (wordBoundaryRegex.test(normalizedText)) {
+        return true;
+      }
+    } else {
+      // Substring match
+      if (normalizedText.includes(normalizedToken)) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Get the best matching token from a list for a given text
+ * Returns the token that was matched, or null
+ */
+function getMatchedToken(normalizedText, tokenList) {
+  if (!normalizedText || !Array.isArray(tokenList)) {
+    return null;
+  }
+
+  for (const token of tokenList) {
+    const normalizedToken = normalizeText(token);
+
+    if (!normalizedToken) {
+      continue;
+    }
+
+    if (normalizedToken.length <= 4) {
+      const wordBoundaryRegex = new RegExp(`\\b${normalizedToken}\\b`);
+      if (wordBoundaryRegex.test(normalizedText)) {
+        return token;
+      }
+    } else {
+      if (normalizedText.includes(normalizedToken)) {
+        return token;
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Get all target names available in dictionary
+ */
+function getAvailableTargets() {
+  return Object.keys(SEMANTIC_DICTIONARY);
+}
+
+/**
+ * Check if a semantic target exists in dictionary
+ */
+function isValidTarget(targetName) {
+  return targetName in SEMANTIC_DICTIONARY;
+}
+
+/**
+ * Get token list for a specific target
+ */
+function getTokensForTarget(targetName) {
+  return SEMANTIC_DICTIONARY[targetName] || [];
+}
+
+module.exports = {
+  SEMANTIC_DICTIONARY,
+  normalizeText,
+  includesAnyToken,
+  getMatchedToken,
+  getAvailableTargets,
+  isValidTarget,
+  getTokensForTarget
+};

package/src/guardian/site-introspection.js

@@ -0,0 +1,257 @@
+/**
+ * Site Introspection - DOM-based capability detection
+ * Deterministically identifies site features by inspecting the loaded page.
+ */
+
+/**
+ * Inspect the page for various capabilities
+ * 
+ * @param {Page} page - Playwright page object (already loaded)
+ * @returns {Promise<Object>} introspection results
+ */
+async function inspectSite(page) {
+  const introspection = {
+    hasLogin: false,
+    hasSignup: false,
+    hasCheckout: false,
+    hasNewsletter: false,
+    hasContactForm: false,
+    hasLanguageSwitch: false,
+    hasContentSignals: false
+  };
+
+  try {
+    // Check for forms - basic existence
+    const hasForms = await page.evaluate(() => {
+      return document.querySelectorAll('form').length > 0;
+    });
+
+    // Check for login indicators — STRONG SIGNALS ONLY
+    introspection.hasLogin = await page.evaluate(() => {
+      const isValidHrefForAuth = (href) => {
+        if (!href) return false;
+        const h = href.trim().toLowerCase();
+        if (h.startsWith('javascript:')) return false;
+        if (h.startsWith('#')) return false;
+        try {
+          const u = new URL(h, window.location.origin);
+          const p = u.pathname.toLowerCase();
+          return /(\/login|\/signin|\/sign-in|\/auth\/login)$|\/(login|signin)(\/|$)/.test(p);
+        } catch (_) {
+          return false;
+        }
+      };
+
+      // Strong signal 1: password input on page
+      const hasPasswordInput = document.querySelectorAll('input[type="password"]').length > 0;
+
+      // Strong signal 2: a form containing a password field
+      const formWithPassword = Array.from(document.querySelectorAll('form')).some(f => f.querySelector('input[type="password"]'));
+
+      // Strong signal 3: link/button to common auth routes
+      const authRouteLink = Array.from(document.querySelectorAll('a')).some(a => isValidHrefForAuth(a.getAttribute('href')));
+
+      return hasPasswordInput || formWithPassword || authRouteLink;
+    });
+
+    // Check for signup indicators — STRONG SIGNALS ONLY
+    introspection.hasSignup = await page.evaluate(() => {
+      const isValidHrefForSignup = (href) => {
+        if (!href) return false;
+        const h = href.trim().toLowerCase();
+        if (h.startsWith('javascript:')) return false;
+        if (h.startsWith('#')) return false;
+        try {
+          const u = new URL(h, window.location.origin);
+          const p = u.pathname.toLowerCase();
+          return /(\/signup|\/register|\/sign-up|\/auth\/signup)$|\/(signup|register|sign-up)(\/|$)/.test(p);
+        } catch (_) {
+          return false;
+        }
+      };
+
+      // Strong signal 1: form that contains a password field AND signup/register text
+      const formWithPasswordAndSignupText = Array.from(document.querySelectorAll('form')).some(form => {
+        const hasPwd = !!form.querySelector('input[type="password"]');
+        if (!hasPwd) return false;
+        const txt = (form.textContent || '').toLowerCase();
+        return /\b(sign ?up|register|create account|join|get started)\b/.test(txt);
+      });
+
+      // Strong signal 2: auth route link to signup/register paths
+      const authRouteLink = Array.from(document.querySelectorAll('a')).some(a => isValidHrefForSignup(a.getAttribute('href')));
+
+      return formWithPasswordAndSignupText || authRouteLink;
+    });
+
+    // Check for checkout/cart indicators — STRONG SIGNALS ONLY
+    introspection.hasCheckout = await page.evaluate(() => {
+      const isValidHrefForCheckout = (href) => {
+        if (!href) return false;
+        const h = href.trim().toLowerCase();
+        if (h.startsWith('javascript:')) return false;
+        if (h.startsWith('#')) return false;
+        try {
+          const u = new URL(h, window.location.origin);
+          const p = u.pathname.toLowerCase();
+          // Strong checkout/cart routes
+          return /(\/cart|\/checkout|\/basket)$|\/(cart|checkout|basket)(\/|$)/.test(p);
+        } catch (_) {
+          return false;
+        }
+      };
+
+      // Strong signal 1: auth route links to cart/checkout/basket
+      const routeLink = Array.from(document.querySelectorAll('a')).some(a => isValidHrefForCheckout(a.getAttribute('href')));
+
+      // Strong signal 2: buttons with explicit commerce actions
+      const commerceButtons = Array.from(document.querySelectorAll('button, input[type="submit"]')).some(btn => {
+        const text = (btn.textContent || btn.value || '').toLowerCase();
+        return /\b(add to cart|buy now|checkout|purchase)\b/.test(text);
+      });
+
+      // Strong signal 3: explicit cart identifiers
+      const cartIndicators = Array.from(document.querySelectorAll('[id*="cart" i], [class*="cart" i], [class*="basket" i]')).length > 0;
+
+      return routeLink || commerceButtons || cartIndicators;
+    });
+
+    // Check for newsletter signup
+    introspection.hasNewsletter = await page.evaluate(() => {
+      // Check for newsletter-specific inputs
+      const hasNewsletterInput = Array.from(document.querySelectorAll('input[type="email"]')).some(input => {
+        const placeholder = (input.placeholder || '').toLowerCase();
+        const id = (input.id || '').toLowerCase();
+        const name = (input.name || '').toLowerCase();
+        return placeholder.match(/newsletter|subscribe|email/) || 
+               id.match(/newsletter|subscribe/) || 
+               name.match(/newsletter|subscribe/);
+      });
+
+      // Check for newsletter text
+      const hasNewsletterText = Array.from(document.querySelectorAll('form, div')).some(el => {
+        const text = (el.textContent || '').toLowerCase();
+        return text.match(/\b(newsletter|subscribe to|stay updated|get updates)\b/);
+      });
+
+      return hasNewsletterInput || hasNewsletterText;
+    });
+
+    // Check for contact form
+    introspection.hasContactForm = await page.evaluate(() => {
+      // Check links
+      const contactLinks = Array.from(document.querySelectorAll('a')).some(a => {
+        const text = (a.textContent || '').toLowerCase();
+        const href = (a.href || '').toLowerCase();
+        return text.match(/\b(contact|contact us|get in touch)\b/) || 
+               href.match(/\/contact/);
+      });
+
+      // Check for forms with contact-related fields
+      const hasContactForm = Array.from(document.querySelectorAll('form')).some(form => {
+        const formText = (form.textContent || '').toLowerCase();
+        const hasNameField = form.querySelectorAll('input[name*="name"]').length > 0;
+        const hasEmailField = form.querySelectorAll('input[type="email"]').length > 0;
+        const hasMessageField = form.querySelectorAll('textarea').length > 0;
+        return formText.match(/contact|message|inquiry/) && hasNameField && hasEmailField && hasMessageField;
+      });
+
+      return contactLinks || hasContactForm;
+    });
+
+    // Check for language switch
+    introspection.hasLanguageSwitch = await page.evaluate(() => {
+      // Check for language selectors
+      const hasLangSelect = Array.from(document.querySelectorAll('select')).some(select => {
+        const id = (select.id || '').toLowerCase();
+        const name = (select.name || '').toLowerCase();
+        return id.match(/lang|language/) || name.match(/lang|language/);
+      });
+
+      // Check for language links (common patterns)
+      const hasLangLinks = Array.from(document.querySelectorAll('a, button')).some(el => {
+        const text = (el.textContent || '').toLowerCase().trim();
+        const ariaLabel = (el.getAttribute('aria-label') || '').toLowerCase();
+        // Common language codes
+        return text.match(/^(en|es|fr|de|it|pt|ja|zh|ko|ru)$/i) || 
+               ariaLabel.match(/language|lang/) ||
+               text.match(/\b(english|español|français|deutsch)\b/i);
+      });
+
+      // Check for globe icon (common language switch indicator)
+      const hasGlobeIcon = Array.from(document.querySelectorAll('[class*="globe"], [class*="lang"], [class*="language"]')).length > 0;
+
+      return hasLangSelect || hasLangLinks || hasGlobeIcon;
+    });
+
+    // Content signals (generic): many internal links + article-like structure
+    introspection.hasContentSignals = await page.evaluate(() => {
+      try {
+        const originHost = window.location.hostname;
+        const internalLinks = Array.from(document.querySelectorAll('a')).filter(a => {
+          const href = a.getAttribute('href');
+          if (!href) return false;
+          const h = href.trim().toLowerCase();
+          if (h.startsWith('javascript:')) return false;
+          if (h.startsWith('#')) return false;
+          try {
+            const u = new URL(h, window.location.origin);
+            return u.hostname === originHost;
+          } catch (_) {
+            return false;
+          }
+        });
+
+        const mainEl = document.querySelector('main') || document.querySelector('article');
+        const paragraphCount = mainEl ? mainEl.querySelectorAll('p').length : 0;
+
+        const manyInternalLinks = internalLinks.length >= 20;
+        const hasArticleStructure = paragraphCount >= 10;
+
+        // Tiny special-case acceptable for Wikipedia (high confidence content site)
+        const isWikipedia = /(^|\.)wikipedia\.org$/.test(window.location.hostname);
+
+        return (manyInternalLinks && hasArticleStructure) || isWikipedia;
+      } catch (_) {
+        return false;
+      }
+    });
+
+  } catch (error) {
+    // If introspection fails, return all false (fail-safe)
+    console.warn(`[Introspection] Error during site inspection: ${error.message}`);
+  }
+
+  return introspection;
+}
+
+/**
+ * Detect site profile based on introspection results
+ * 
+ * @param {Object} introspection - Result from inspectSite()
+ * @returns {string} Profile: 'ecommerce', 'saas', 'content', or 'unknown'
+ */
+function detectProfile(introspection) {
+  // E-commerce: strong checkout/cart signals
+  if (introspection.hasCheckout) {
+    return 'ecommerce';
+  }
+
+  // SaaS: strong auth signals (login/signup) and no checkout
+  if ((introspection.hasLogin || introspection.hasSignup)) {
+    return 'saas';
+  }
+
+  // Content site: absence of ecommerce & saas; presence of content signals
+  if (introspection.hasLanguageSwitch || introspection.hasContactForm || introspection.hasContentSignals) {
+    return 'content';
+  }
+
+  // Unknown: nothing detected
+  return 'unknown';
+}
+
+module.exports = {
+  inspectSite,
+  detectProfile
+};