@odavl/guardian 0.1.0-rc1 → 0.2.0

package/src/guardian/flag-validator.js

@@ -0,0 +1,97 @@
+/**
+ * Guardian Flag Validation
+ * Early validation of flags and options to catch errors before module load.
+ */
+
+const VALID_SUBCOMMANDS = [
+  'init', 'protect', 'reality', 'attempt', 'baseline',
+  'presets', 'evaluate', 'version', 'flow', 'scan', 'smoke'
+];
+
+const VALID_GLOBAL_FLAGS = [
+  '--help', '-h', '--version', '-v', '--debug'
+];
+
+const VALID_SUBCOMMAND_FLAGS = {
+  'scan': ['--url', '--preset', '--artifacts', '--policy', '--headful', '--no-trace', '--no-screenshots', '--watch', '-w', '--fast', '--fail-fast', '--timeout-profile', '--attempts', '--parallel', '--help', '-h'],
+  'protect': ['--url', '--policy', '--webhook', '--watch', '-w', '--fast', '--fail-fast', '--timeout-profile', '--attempts', '--parallel', '--help', '-h'],
+  'reality': ['--url', '--attempts', '--artifacts', '--policy', '--discover', '--universal', '--webhook', '--headful', '--watch', '-w', '--no-trace', '--no-screenshots', '--fast', '--fail-fast', '--timeout-profile', '--parallel', '--help', '-h'],
+  'attempt': ['--url', '--attempt', '--artifacts', '--headful', '--no-trace', '--no-screenshots', '--help', '-h'],
+  'smoke': ['--url', '--headful', '--budget-ms', '--help', '-h'],
+  'baseline': [],
+  'init': ['--preset', '--help', '-h'],
+  'presets': ['--help', '-h']
+};
+
+function validateFlags(argv) {
+  const args = argv.slice(2);
+  if (args.length === 0) return { valid: true };
+
+  const subcommand = args[0];
+
+  // Check if it's a global flag or help
+  if (VALID_GLOBAL_FLAGS.includes(subcommand)) {
+    return { valid: true };
+  }
+
+  // Check if subcommand is valid
+  if (subcommand && !subcommand.startsWith('-') && !VALID_SUBCOMMANDS.includes(subcommand)) {
+    return {
+      valid: false,
+      error: `Unknown command '${subcommand}'`,
+      hint: `Valid commands: ${VALID_SUBCOMMANDS.slice(0, 5).join(', ')}, …`
+    };
+  }
+
+  // If we have a valid subcommand, validate its flags
+  if (VALID_SUBCOMMANDS.includes(subcommand)) {
+    const validFlags = VALID_SUBCOMMAND_FLAGS[subcommand] || [];
+    const subArgs = args.slice(1);
+
+    for (let i = 0; i < subArgs.length; i++) {
+      const arg = subArgs[i];
+      if (arg.startsWith('--') || arg.startsWith('-')) {
+        const flagName = arg.split('=')[0]; // Handle --flag=value
+        if (!validFlags.includes(flagName)) {
+          return {
+            valid: false,
+            error: `Unknown flag '${flagName}' for command '${subcommand}'`,
+            hint: `Run 'guardian ${subcommand} --help' for valid options.`
+          };
+        }
+        // Check if flag expects a value
+        if ((flagName.includes('--') && !arg.includes('=')) || (flagName === '-w')) {
+          const expectsValue = ![
+            '--headful', '--watch', '-w', '--discover', '--universal',
+            '--no-trace', '--no-screenshots', '--help', '-h'
+          ].includes(flagName);
+
+          if (expectsValue && i + 1 < subArgs.length && subArgs[i + 1].startsWith('-')) {
+            return {
+              valid: false,
+              error: `Flag '${flagName}' requires a value`,
+              hint: `Usage: guardian ${subcommand} ${flagName} <value>`
+            };
+          }
+        }
+      }
+    }
+  }
+
+  return { valid: true };
+}
+
+function reportFlagError(validation) {
+  if (!validation.valid) {
+    console.error(`Error: ${validation.error}`);
+    if (validation.hint) {
+      console.error(`Hint:  ${validation.hint}`);
+    }
+  }
+}
+
+module.exports = {
+  validateFlags,
+  reportFlagError,
+  VALID_SUBCOMMANDS
+};

package/src/guardian/flow-executor.js

@@ -5,12 +5,85 @@
 
 const fs = require('fs');
 const path = require('path');
+const { waitForOutcome } = require('./wait-for-outcome');
+
+const MAX_ACTION_RETRIES = 1;
+const RETRY_BACKOFF_MS = 150; // deterministic, small backoff
+
+function validateFlowDefinition(flow) {
+  if (!flow || !Array.isArray(flow.steps) || flow.steps.length === 0) {
+    return { ok: false, reason: 'Flow misconfigured: no steps defined (add at least one step).' };
+  }
+
+  for (let i = 0; i < flow.steps.length; i++) {
+    const step = flow.steps[i] || {};
+    const needsTarget = ['click', 'type', 'submit', 'waitFor', 'navigate'];
+    if (needsTarget.includes(step.type) && !step.target) {
+      return { ok: false, reason: `Flow misconfigured: step ${i + 1} (${step.type}) missing target selector.` };
+    }
+  }
+
+  return { ok: true };
+}
 
 class GuardianFlowExecutor {
   constructor(options = {}) {
     this.timeout = options.timeout || 30000; // 30 seconds per step
     this.screenshotOnStep = options.screenshotOnStep !== false; // Screenshot each step by default
     this.safety = options.safety || null; // Safety guard instance (optional)
+    this.baseUrl = options.baseUrl || null; // For origin checks
+    this.quiet = options.quiet === true;
+    this.log = (...args) => {
+      if (!this.quiet) console.log(...args);
+    };
+    this.warn = (...args) => {
+      if (!this.quiet) console.warn(...args);
+    };
+  }
+
+  async runActionWithRetry(step, actionLabel, attemptFn) {
+    let attempt = 0;
+    let lastErr = null;
+    let lastResult = null;
+
+    while (attempt <= MAX_ACTION_RETRIES) {
+      try {
+        lastResult = await attemptFn();
+        if (lastResult && lastResult.success) {
+          if (attempt > 0) {
+            lastResult.retried = true;
+            lastResult.retryCount = attempt;
+            this.log(`   ✅ Retry succeeded for action ${actionLabel}`);
+          }
+          return lastResult;
+        }
+
+        if (lastResult && lastResult.retryable === false) {
+          return lastResult;
+        }
+
+        if (lastResult && lastResult.error) {
+          lastErr = lastResult.error instanceof Error ? lastResult.error : new Error(lastResult.error);
+        }
+      } catch (error) {
+        lastErr = error;
+      }
+
+      if (attempt >= MAX_ACTION_RETRIES || !isRetryableActionError(lastErr)) {
+        const errorMsg = lastErr ? lastErr.message : 'Action failed';
+        const severity = classifyError(step, lastErr || new Error('Action failed'));
+        if (attempt > 0) {
+          this.log(`   ❌ Retry ${attempt}/${MAX_ACTION_RETRIES} failed for action ${actionLabel}: ${errorMsg}`);
+        }
+        return { success: false, error: errorMsg, severity, retryCount: attempt > 0 ? attempt : 0 };
+      }
+
+      attempt++;
+      this.log(`   🔁 Retry ${attempt}/${MAX_ACTION_RETRIES} attempted for action ${actionLabel}${lastErr && lastErr.message ? ` (${lastErr.message})` : ''}`);
+      await deterministicDelay(RETRY_BACKOFF_MS);
+    }
+
+    return lastResult || { success: false, error: 'Action failed', severity: 'hard' };
   }
 
   /**
@@ -37,7 +110,7 @@ class GuardianFlowExecutor {
    */
   async executeStep(page, step, stepIndex) {
     try {
-      console.log(`   Step ${stepIndex + 1}: ${step.type} ${step.target || ''}`);
+      this.log(`   Step ${stepIndex + 1}: ${step.type} ${step.target || ''}`);
 
       // Safety check for destructive actions
       if (this.safety) {
@@ -73,12 +146,14 @@ class GuardianFlowExecutor {
           return {
             success: false,
             error: `Unknown step type: ${step.type}`,
+            severity: 'hard'
           };
       }
     } catch (error) {
       return {
         success: false,
         error: error.message,
+        severity: classifyError(step, error)
       };
     }
   }
@@ -97,7 +172,7 @@ class GuardianFlowExecutor {
       });
       return { success: true, error: null };
     } catch (error) {
-      return { success: false, error: error.message };
+      return { success: false, error: error.message, severity: classifyError(step, error) };
     }
   }
 
@@ -108,18 +183,20 @@ class GuardianFlowExecutor {
    * @returns {Promise<object>} Result
    */
   async stepClick(page, step) {
-    try {
+    return this.runActionWithRetry(step, 'click', async () => {
+      const initialUrl = page.url();
+      const waitPromise = waitForOutcome(page, {
+        actionType: 'click',
+        baseOrigin: this.baseUrl ? new URL(this.baseUrl).origin : null,
+        initialUrl,
+        expectNavigation: !!step.waitForNavigation,
+        maxWait: Math.min(this.timeout, 3500)
+      });
       await page.click(step.target, { timeout: this.timeout });
-      
-      // Wait for navigation if expected
-      if (step.waitForNavigation) {
-        await page.waitForLoadState('domcontentloaded');
-      }
-      
+      const waitResult = await waitPromise;
+      this.log(`   ⏱️  wait resolved by ${waitResult.reason}`);
       return { success: true, error: null };
-    } catch (error) {
-      return { success: false, error: error.message };
-    }
+    });
   }
 
   /**
@@ -129,21 +206,18 @@ class GuardianFlowExecutor {
    * @returns {Promise<object>} Result
    */
   async stepType(page, step) {
-    try {
-      // Clear field first if specified
+    return this.runActionWithRetry(step, 'type', async () => {
       if (step.clear !== false) {
         await page.fill(step.target, '');
       }
-      
+
       await page.type(step.target, step.value, {
         timeout: this.timeout,
         delay: step.delay || 50, // Simulate human typing
       });
       
       return { success: true, error: null };
-    } catch (error) {
-      return { success: false, error: error.message };
-    }
+    });
   }
 
   /**
@@ -153,22 +227,132 @@ class GuardianFlowExecutor {
    * @returns {Promise<object>} Result
    */
   async stepSubmit(page, step) {
-    try {
-      // Find submit button within form or use provided selector
-      if (step.target) {
-        await page.click(step.target, { timeout: this.timeout });
-      } else {
-        // Find first submit button
-        await page.click('button[type="submit"]', { timeout: this.timeout });
+    return this.runActionWithRetry(step, 'submit', async () => {
+      const { captureBeforeState, captureAfterState, evaluateSuccess } = require('./success-evaluator');
+
+      const submitSelector = step.target || 'button[type="submit"]';
+      const submitHandle = await page.$(submitSelector);
+      const before = await captureBeforeState(page, submitHandle);
+
+      const requests = [];
+      const responses = [];
+      const consoleErrors = [];
+      let initialUrl = page.url();
+      let navChanged = false;
+
+      const onRequest = (req) => { requests.push(req); };
+      const onResponse = (res) => {
+        try {
+          const req = res.request();
+          if (!req || requests.includes(req)) {
+            responses.push(res);
+          }
+        } catch {
+          responses.push(res);
+        }
+      };
+      const onConsole = (msg) => {
+        if (msg.type() === 'error') {
+          consoleErrors.push({ type: msg.type(), text: msg.text() });
+        }
+      };
+      const onFrameNav = () => {
+        try {
+          const nowUrl = page.url();
+          if (nowUrl && nowUrl !== initialUrl) navChanged = true;
+        } catch {}
+      };
+
+      page.on('request', onRequest);
+      page.on('response', onResponse);
+      page.on('console', onConsole);
+      page.on('framenavigated', onFrameNav);
+
+      try {
+        if (submitHandle) {
+          await submitHandle.click({ timeout: this.timeout });
+        } else {
+          await page.click(submitSelector, { timeout: this.timeout });
+        }
+
+        const baseOrigin = this.baseUrl ? new URL(this.baseUrl).origin : (new URL(initialUrl)).origin;
+        const waitResult = await waitForOutcome(page, {
+          actionType: 'submit',
+          baseOrigin: baseOrigin,
+          initialUrl,
+          expectNavigation: true,
+          includeUrlChange: false,
+          maxWait: Math.min(4000, this.timeout)
+        });
+        this.log(`   ⏱️  wait resolved by ${waitResult.reason}`);
+
+        const originalFormSelector = before.state.formSelector;
+        const after = await captureAfterState(page, originalFormSelector);
+
+        const evalResult = evaluateSuccess(before, after, {
+          requests,
+          responses,
+          consoleErrors,
+          navChanged,
+          baseOrigin,
+        });
+
+        const topReasonsArr = (evalResult.reasons || []).slice(0, 3);
+        const topReasons = topReasonsArr.join(' + ');
+        this.log(`   SUBMIT: ${evalResult.status.toUpperCase()} (confidence: ${evalResult.confidence}) — ${topReasons || 'no signals'}`);
+        if (topReasonsArr.length > 0) {
+          this.log('     Reasons:');
+          topReasonsArr.forEach(r => this.log(`       - ${r}`));
+        }
+        const ev = evalResult.evidence || {};
+        const net = Array.isArray(ev.network) ? ev.network : [];
+        const primary = net.find(n => (n.method === 'POST' || n.method === 'PUT') && n.status != null) || net[0];
+        const reqLine = (() => {
+          if (!primary) return null;
+          try {
+            const p = new URL(primary.url);
+            return `request: ${primary.method} ${p.pathname} → ${primary.status}`;
+          } catch { return `request: ${primary.method} ${primary.url} → ${primary.status}`; }
+        })();
+        const navLine = (ev.urlChanged || navChanged) ? (() => {
+          try {
+            const from = new URL(before.url).pathname;
+            const to = new URL(after.url).pathname;
+            return `navigation: ${from} → ${to}`;
+          } catch { return `navigation: changed`; }
+        })() : null;
+        const formStates = [];
+        if (ev.formCleared) formStates.push('cleared');
+        if (ev.formDisabled) formStates.push('disabled');
+        if (ev.formDisappeared) formStates.push('disappeared');
+        const formLine = formStates.length ? `form: ${formStates.join(', ')}` : null;
+        const errorLines = [];
+        if ((ev.ariaInvalidDelta || 0) > 0) errorLines.push('aria-invalid increased');
+        if ((ev.alertRegionDelta || 0) > 0) errorLines.push('role=alert updated');
+        const consoleErr = (consoleErrors || [])[0];
+        const consoleLine = consoleErr ? `console.error: "${String(consoleErr.text).slice(0, 120)}"` : null;
+        const evidenceLines = [reqLine, navLine, formLine, ...errorLines.map(e => `error: ${e}`), consoleLine].filter(Boolean);
+        if (evidenceLines.length > 0) {
+          this.log('     Evidence:');
+          evidenceLines.slice(0, 3).forEach(line => this.log(`       - ${line}`));
+        }
+
+        const ok = evalResult.status === 'success';
+        const errMsg = ok ? null : `Outcome evaluation: ${evalResult.status}`;
+        return {
+          success: ok,
+          error: errMsg,
+          successEval: evalResult,
+          severity: evalResult.status === 'failure' ? 'hard' : 'soft',
+          retryable: ok ? undefined : false
+        };
+      } finally {
+        page.off('request', onRequest);
+        page.off('response', onResponse);
+        page.off('console', onConsole);
+        page.off('framenavigated', onFrameNav);
       }
-      
-      // Wait for navigation
-      await page.waitForLoadState('domcontentloaded');
-      
-      return { success: true, error: null };
-    } catch (error) {
-      return { success: false, error: error.message };
-    }
+    });
   }
 
   /**
@@ -186,7 +370,7 @@ class GuardianFlowExecutor {
       
       return { success: true, error: null };
     } catch (error) {
-      return { success: false, error: error.message };
+      return { success: false, error: error.message, severity: classifyError(step, error) };
     }
   }
 
@@ -202,7 +386,7 @@ class GuardianFlowExecutor {
       await page.waitForTimeout(duration);
       return { success: true, error: null };
     } catch (error) {
-      return { success: false, error: error.message };
+      return { success: false, error: error.message, severity: classifyError(step, error) };
     }
   }
 
@@ -242,6 +426,7 @@ class GuardianFlowExecutor {
    * @returns {Promise<object>} Flow result
    */
   async executeFlow(page, flow, artifactsDir, baseUrl = null) {
+    this.baseUrl = baseUrl || this.baseUrl;
     const result = {
       flowId: flow.id,
       flowName: flow.name,
@@ -251,8 +436,11 @@ class GuardianFlowExecutor {
       failedStep: null,
       error: null,
       screenshots: [],
-      durationMs: 0
+      durationMs: 0,
+      outcome: 'SUCCESS',
+      failureReasons: []
     };
+    let hadRetrySuccess = false;
 
     // Normalize steps with optional baseUrl substitution
     const steps = (flow.steps || []).map((step) => {
@@ -270,8 +458,8 @@ class GuardianFlowExecutor {
 
     let startedAt = Date.now();
     try {
-      console.log(`\n🎬 Executing flow: ${flow.name}`);
-      console.log(`📋 Steps: ${steps.length}`);
+      this.log(`\n🎬 Executing flow: ${flow.name}`);
+      this.log(`📋 Steps: ${steps.length}`);
 
       for (let i = 0; i < steps.length; i++) {
         const step = steps[i];
@@ -295,21 +483,63 @@ class GuardianFlowExecutor {
           }
         }
 
+        // If submit step returns evaluator details, attach them
+        if (step.type === 'submit' && stepResult && stepResult.successEval) {
+          result.successEval = stepResult.successEval;
+        }
+
+        if (stepResult.retried || (stepResult.retryCount && stepResult.retryCount > 0)) {
+          if (stepResult.success) {
+            hadRetrySuccess = true;
+          }
+          result.retryCount = (result.retryCount || 0) + (stepResult.retryCount || 0);
+        }
+
         // Check if step failed
         if (!stepResult.success) {
           result.failedStep = i + 1;
           result.error = stepResult.error;
-          console.log(`   ❌ Step failed: ${stepResult.error}`);
-          return result;
+          const severity = stepResult.severity || 'hard';
+          const reason = `${step.type} failed: ${stepResult.error}`;
+          result.failureReasons.push(reason);
+          if (severity === 'soft') {
+            result.outcome = result.outcome === 'FAILURE' ? 'FAILURE' : 'FRICTION';
+            this.log(`   ⚠️  Soft failure: ${stepResult.error}`);
+            continue;
+          } else {
+            result.outcome = 'FAILURE';
+            this.log(`   ❌ Step failed: ${stepResult.error}`);
+            break;
+          }
         }
 
         result.stepsExecuted++;
-        console.log(`   ✅ Step ${i + 1} completed`);
+        this.log(`   ✅ Step ${i + 1} completed`);
       }
 
-      result.success = true;
+      // If we have an outcome evaluation from a submit, trust it for overall flow success
+      if (result.successEval) {
+        result.success = result.successEval.status === 'success';
+        if (!result.success && result.outcome !== 'FAILURE') {
+          result.outcome = result.successEval.status === 'friction' ? 'FRICTION' : 'FAILURE';
+        }
+      } else {
+        result.success = result.outcome !== 'FAILURE';
+      }
+      if (hadRetrySuccess && result.outcome === 'SUCCESS') {
+        result.outcome = 'FRICTION';
+      }
+      if (result.outcome === 'SUCCESS' && !result.success) {
+        result.outcome = 'FAILURE';
+      }
       result.durationMs = Date.now() - startedAt;
-      console.log(`✅ Flow completed successfully`);
+      if (result.outcome === 'SUCCESS') {
+        this.log(`✅ Flow completed successfully`);
+      } else if (result.outcome === 'FRICTION') {
+        this.log(`⚠️  Flow completed with friction`);
+      } else {
+        this.log(`❌ Flow completed with failure`);
+      }
       
       return result;
     } catch (error) {
@@ -318,6 +548,7 @@ class GuardianFlowExecutor {
       }
       result.error = error.message;
       console.error(`❌ Flow execution failed: ${error.message}`);
+      result.outcome = result.outcome === 'SUCCESS' ? 'FAILURE' : result.outcome;
       return result;
     }
   }
@@ -371,4 +602,38 @@ class GuardianFlowExecutor {
   }
 }
 
-module.exports = { GuardianFlowExecutor };
+function classifyError(step, error) {
+  const msg = (error && error.message) ? error.message.toLowerCase() : '';
+  const isTimeout = msg.includes('timeout');
+  const isNavCrash = msg.includes('target closed') || msg.includes('page crashed') || msg.includes('net::');
+  const missingSelector = msg.includes('not found') || msg.includes('waiting for selector');
+
+  if (isNavCrash) return 'hard';
+  if (missingSelector) return 'hard';
+  if (step && step.type !== 'waitFor' && isTimeout) return 'hard';
+  if (isTimeout) return 'soft';
+  return 'hard';
+}
+
+function deterministicDelay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function isRetryableActionError(error) {
+  if (!error) return false;
+  const msg = (error.message || String(error)).toLowerCase();
+  if (!msg) return false;
+
+  const isTargetClosed = msg.includes('target closed') || msg.includes('page crashed') || msg.includes('browser has disconnected');
+  const isMissingSelector = msg.includes('not found') || msg.includes('waiting for selector') || msg.includes('failed to find element') || msg.includes('selector resolved to') && msg.includes('null');
+  if (isTargetClosed) return false;
+  if (isMissingSelector) return false;
+
+  const isTimeout = msg.includes('timeout');
+  const isDetached = msg.includes('detached') || msg.includes('not attached') || msg.includes('stale element');
+  const isNavRace = msg.includes('execution context was destroyed') || (msg.includes('navigation') && msg.includes('race'));
+
+  return isTimeout || isDetached || isNavRace;
+}
+
+module.exports = { GuardianFlowExecutor, validateFlowDefinition };

package/src/guardian/language-detection.js

@@ -0,0 +1,99 @@
+/**
+ * Language Detection
+ * 
+ * Deterministic language detection from HTML attributes.
+ * No guessing, no AI. Only reads explicit language declarations.
+ */
+
+/**
+ * Detect page language from HTML
+ * 
+ * Detection order:
+ * 1. <html lang="..."> attribute
+ * 2. <meta http-equiv="content-language" ...> attribute
+ * 3. fallback: "unknown"
+ * 
+ * @param {Page} page - Playwright page object
+ * @returns {Promise<string>} BCP-47 language code or "unknown"
+ */
+async function detectLanguage(page) {
+  try {
+    // Try <html lang="...">
+    const htmlLang = await page.evaluate(() => {
+      const htmlElement = document.documentElement;
+      return htmlElement.getAttribute('lang');
+    });
+
+    if (htmlLang && htmlLang.trim()) {
+      // Return the language code (e.g., "de", "de-DE", "en", "en-US")
+      return htmlLang.trim().toLowerCase();
+    }
+
+    // Try <meta http-equiv="content-language" ...>
+    const metaLang = await page.evaluate(() => {
+      const meta = document.querySelector('meta[http-equiv="content-language"]');
+      return meta ? meta.getAttribute('content') : null;
+    });
+
+    if (metaLang && metaLang.trim()) {
+      return metaLang.trim().toLowerCase();
+    }
+
+    // Fallback
+    return 'unknown';
+  } catch (error) {
+    // If evaluation fails, return unknown
+    return 'unknown';
+  }
+}
+
+/**
+ * Parse BCP-47 language code to get primary language
+ * e.g., "de-DE" -> "de", "en-US" -> "en"
+ */
+function getPrimaryLanguage(languageCode) {
+  if (!languageCode || languageCode === 'unknown') {
+    return 'unknown';
+  }
+
+  // Extract primary language (before first hyphen)
+  const primary = languageCode.split('-')[0].toLowerCase();
+  return primary || 'unknown';
+}
+
+/**
+ * Get human-readable language name from code
+ */
+const LANGUAGE_NAMES = {
+  'de': 'German',
+  'en': 'English',
+  'es': 'Spanish',
+  'fr': 'French',
+  'pt': 'Portuguese',
+  'it': 'Italian',
+  'nl': 'Dutch',
+  'sv': 'Swedish',
+  'ar': 'Arabic',
+  'zh': 'Chinese',
+  'ja': 'Japanese',
+  'ko': 'Korean',
+  'ru': 'Russian',
+  'pl': 'Polish',
+  'unknown': 'Unknown'
+};
+
+function getLanguageName(languageCode) {
+  if (!languageCode || languageCode === 'unknown') {
+    return 'Unknown';
+  }
+
+  const primary = getPrimaryLanguage(languageCode);
+  return LANGUAGE_NAMES[primary] || `Unknown (${primary})`;
+}
+
+module.exports = {
+  detectLanguage,
+  getPrimaryLanguage,
+  getLanguageName,
+  LANGUAGE_NAMES
+};