@lokascript/semantic 1.0.0 → 1.1.0

package/src/generators/profiles/spanishMexico.ts

@@ -0,0 +1,176 @@
+/**
+ * Mexican Spanish Language Profile
+ *
+ * ⚠️  EXAMPLE/TEST ONLY - NOT FOR PRODUCTION USE
+ *
+ * This profile demonstrates the language variant feature:
+ * - Extends base Spanish using `extends: 'es'`
+ * - Overrides specific keywords with regional alternatives
+ * - Reuses the Spanish tokenizer
+ *
+ * The Mexican-specific vocabulary (ahorita, jalar, aventar, etc.) is
+ * illustrative and has NOT been validated by native speakers.
+ *
+ * To create a production-ready regional variant, consult native speakers
+ * to verify vocabulary choices and completeness.
+ */
+
+import type { LanguageProfile } from './types';
+
+export const spanishMexicoProfile: LanguageProfile = {
+  code: 'es-MX',
+  name: 'Spanish (Mexico)',
+  nativeName: 'Español (México)',
+  direction: 'ltr',
+  wordOrder: 'SVO',
+  markingStrategy: 'preposition',
+  usesSpaces: true,
+  defaultVerbForm: 'infinitive',
+  extends: 'es', // Inherit from base Spanish
+
+  verb: {
+    position: 'start',
+    subjectDrop: true,
+  },
+  references: {
+    me: 'yo',
+    it: 'ello',
+    you: 'tú', // Mexico uses tú (not vos like Argentina)
+    result: 'resultado',
+    event: 'evento',
+    target: 'objetivo',
+    body: 'cuerpo',
+  },
+  possessive: {
+    marker: 'de',
+    markerPosition: 'before-property',
+    usePossessiveAdjectives: true,
+    specialForms: {
+      me: 'mi',
+      it: 'su',
+      you: 'tu',
+    },
+    keywords: {
+      mi: 'me',
+      tu: 'you',
+      su: 'it',
+    },
+  },
+  roleMarkers: {
+    destination: { primary: 'en', alternatives: ['sobre', 'a'], position: 'before' },
+    source: { primary: 'de', alternatives: ['desde'], position: 'before' },
+    patient: { primary: '', position: 'before' },
+    style: { primary: 'con', position: 'before' },
+  },
+  keywords: {
+    // Class/Attribute operations - Mexican alternatives
+    toggle: {
+      primary: 'alternar',
+      alternatives: ['cambiar', 'conmutar', 'switchear'], // "switchear" is Spanglish common in MX tech
+      normalized: 'toggle',
+    },
+    add: { primary: 'agregar', alternatives: ['añadir', 'meter'], normalized: 'add' },
+    remove: {
+      primary: 'quitar',
+      alternatives: ['eliminar', 'borrar', 'sacar'], // "borrar" more common in MX
+      normalized: 'remove',
+    },
+    // Content operations
+    put: { primary: 'poner', alternatives: ['colocar', 'meter'], normalized: 'put' },
+    append: { primary: 'añadir', normalized: 'append' },
+    prepend: { primary: 'anteponer', normalized: 'prepend' },
+    take: { primary: 'tomar', alternatives: ['agarrar'], normalized: 'take' }, // "agarrar" more MX
+    make: { primary: 'hacer', alternatives: ['crear'], normalized: 'make' },
+    clone: { primary: 'clonar', alternatives: ['copiar'], normalized: 'clone' },
+    swap: { primary: 'intercambiar', alternatives: ['cambiar'], normalized: 'swap' },
+    morph: { primary: 'transformar', alternatives: ['convertir'], normalized: 'morph' },
+    // Variable operations
+    set: { primary: 'establecer', alternatives: ['fijar', 'definir', 'setear'], normalized: 'set' },
+    get: { primary: 'obtener', alternatives: ['conseguir', 'jalar'], normalized: 'get' },
+    increment: {
+      primary: 'incrementar',
+      alternatives: ['aumentar', 'subir'],
+      normalized: 'increment',
+    },
+    decrement: {
+      primary: 'decrementar',
+      alternatives: ['disminuir', 'bajar'],
+      normalized: 'decrement',
+    },
+    log: { primary: 'registrar', alternatives: ['imprimir', 'loguear'], normalized: 'log' },
+    // Visibility
+    show: { primary: 'mostrar', alternatives: ['enseñar'], normalized: 'show' },
+    hide: { primary: 'ocultar', alternatives: ['esconder'], normalized: 'hide' },
+    transition: { primary: 'transición', alternatives: ['animar'], normalized: 'transition' },
+    // Events
+    on: { primary: 'en', alternatives: ['cuando', 'al'], normalized: 'on' },
+    trigger: { primary: 'disparar', alternatives: ['activar'], normalized: 'trigger' },
+    send: { primary: 'enviar', alternatives: ['mandar'], normalized: 'send' }, // "mandar" more MX
+    // DOM focus
+    focus: { primary: 'enfocar', normalized: 'focus' },
+    blur: { primary: 'desenfocar', normalized: 'blur' },
+    // Common event names
+    click: { primary: 'clic', alternatives: ['hacer clic', 'dar clic'], normalized: 'click' },
+    hover: { primary: 'sobrevolar', alternatives: ['pasar encima'], normalized: 'hover' },
+    submit: { primary: 'envío', alternatives: ['enviar'], normalized: 'submit' },
+    input: { primary: 'entrada', alternatives: ['introducir'], normalized: 'input' },
+    change: { primary: 'cambio', alternatives: ['cambiar'], normalized: 'change' },
+    // Navigation
+    go: { primary: 'ir', alternatives: ['navegar'], normalized: 'go' },
+    // Async - Mexican variants
+    wait: {
+      primary: 'esperar',
+      alternatives: ['ahorita', 'aguantar'], // "ahorita" is distinctly Mexican
+      normalized: 'wait',
+    },
+    fetch: {
+      primary: 'buscar',
+      alternatives: ['obtener', 'jalar', 'traer'], // "jalar" (pull) common in MX tech
+      normalized: 'fetch',
+    },
+    settle: { primary: 'estabilizar', normalized: 'settle' },
+    // Control flow
+    if: { primary: 'si', normalized: 'if' },
+    when: { primary: 'cuando', normalized: 'when' },
+    where: { primary: 'donde', normalized: 'where' },
+    else: { primary: 'sino', alternatives: ['de lo contrario', 'si no'], normalized: 'else' },
+    repeat: { primary: 'repetir', normalized: 'repeat' },
+    for: { primary: 'para', normalized: 'for' },
+    while: { primary: 'mientras', normalized: 'while' },
+    continue: { primary: 'continuar', alternatives: ['seguir'], normalized: 'continue' },
+    halt: { primary: 'detener', alternatives: ['parar'], normalized: 'halt' },
+    throw: {
+      primary: 'lanzar',
+      alternatives: ['aventar', 'arrojar'], // "aventar" is Mexican
+      normalized: 'throw',
+    },
+    call: { primary: 'llamar', normalized: 'call' },
+    return: { primary: 'retornar', alternatives: ['devolver', 'regresar'], normalized: 'return' },
+    then: { primary: 'entonces', alternatives: ['luego', 'después'], normalized: 'then' },
+    and: { primary: 'y', alternatives: ['además', 'también'], normalized: 'and' },
+    end: { primary: 'fin', alternatives: ['final', 'terminar'], normalized: 'end' },
+    // Advanced
+    js: { primary: 'js', normalized: 'js' },
+    async: { primary: 'asíncrono', normalized: 'async' },
+    tell: { primary: 'decir', normalized: 'tell' },
+    default: { primary: 'predeterminar', alternatives: ['por defecto'], normalized: 'default' },
+    init: { primary: 'iniciar', alternatives: ['inicializar', 'arrancar'], normalized: 'init' },
+    behavior: { primary: 'comportamiento', normalized: 'behavior' },
+    install: { primary: 'instalar', normalized: 'install' },
+    measure: { primary: 'medir', normalized: 'measure' },
+    // Modifiers
+    into: { primary: 'en', alternatives: ['dentro de'], normalized: 'into' },
+    before: { primary: 'antes', normalized: 'before' },
+    after: { primary: 'después', normalized: 'after' },
+    // Event modifiers
+    until: { primary: 'hasta', normalized: 'until' },
+    event: { primary: 'evento', normalized: 'event' },
+    from: { primary: 'de', alternatives: ['desde'], normalized: 'from' },
+  },
+  eventHandler: {
+    keyword: { primary: 'al', alternatives: ['cuando', 'en'], normalized: 'on' },
+    sourceMarker: { primary: 'de', alternatives: ['desde'], position: 'before' },
+    eventMarker: { primary: 'al', alternatives: ['cuando'], position: 'before' },
+    temporalMarkers: ['cuando', 'al'],
+  },
+};

package/src/generators/profiles/thai.ts

@@ -83,6 +83,12 @@ export const thaiProfile: LanguageProfile = {
     // DOM focus
     focus: { primary: 'โฟกัส', alternatives: [], normalized: 'focus' },
     blur: { primary: 'เบลอ', alternatives: [], normalized: 'blur' },
+    // Common event names (for event handler patterns)
+    click: { primary: 'คลิก', normalized: 'click' },
+    hover: { primary: 'โฮเวอร์', alternatives: ['วางเมาส์'], normalized: 'hover' },
+    submit: { primary: 'ส่ง', alternatives: ['ส่งข้อมูล'], normalized: 'submit' },
+    input: { primary: 'ป้อน', alternatives: ['กรอก'], normalized: 'input' },
+    change: { primary: 'เปลี่ยน', alternatives: ['เปลี่ยนแปลง'], normalized: 'change' },
     // Navigation
     go: { primary: 'ไป', alternatives: ['ไปที่'], normalized: 'go' },
     // Async
@@ -128,5 +134,10 @@ export const thaiProfile: LanguageProfile = {
   eventHandler: {
     keyword: { primary: 'เมื่อ', alternatives: ['ตอน'], normalized: 'on' },
     sourceMarker: { primary: 'จาก', position: 'before' },
+    // Event marker: เมื่อ (when), used in SVO pattern
+    // Pattern: เมื่อ [event] [verb] [patient] ใน [destination?]
+    // Example: เมื่อ คลิก สลับ .active ใน #button
+    eventMarker: { primary: 'เมื่อ', alternatives: ['ตอน'], position: 'before' },
+    temporalMarkers: ['เมื่อ', 'ตอน'], // temporal conjunctions (when)
   },
 };

package/src/generators/profiles/turkish.ts

@@ -45,8 +45,36 @@ export const turkishProfile: LanguageProfile = {
     },
   },
   roleMarkers: {
-    patient: { primary: 'i', alternatives: ['ı', 'u', 'ü'], position: 'after' }, // Accusative
-    destination: { primary: 'e', alternatives: ['a', 'de', 'da', 'te', 'ta'], position: 'after' }, // Dative/Locative
+    patient: {
+      primary: 'i',
+      alternatives: ['ı', 'u', 'ü', 'yi', 'yı', 'yu', 'yü', 'ni', 'nı', 'nu', 'nü'],
+      position: 'after',
+    }, // Accusative (with buffer consonants y/n)
+    destination: {
+      primary: 'e',
+      // Include both dative (e/a) and genitive (ın/in/un/ün) for possessive patterns
+      // Genitive is used in "X's Y" patterns: #button ın .active = "#button's .active"
+      alternatives: [
+        'a',
+        'ye',
+        'ya',
+        'ne',
+        'na',
+        'de',
+        'da',
+        'te',
+        'ta',
+        'ın',
+        'in',
+        'un',
+        'ün',
+        'nın',
+        'nin',
+        'nun',
+        'nün',
+      ],
+      position: 'after',
+    }, // Dative/Locative + Genitive (with buffer consonants)
     source: { primary: 'den', alternatives: ['dan', 'ten', 'tan'], position: 'after' }, // Ablative
     style: { primary: 'le', alternatives: ['la', 'yle', 'yla'], position: 'after' }, // Instrumental
     event: { primary: 'i', alternatives: ['ı', 'u', 'ü'], position: 'after' }, // Event as accusative
@@ -59,10 +87,10 @@ export const turkishProfile: LanguageProfile = {
     // Content operations
     put: { primary: 'koy', normalized: 'put' },
     append: { primary: 'ekle', normalized: 'append' },
-    take: { primary: 'al', normalized: 'take' },
+    take: { primary: 'tut', normalized: 'take' }, // al removed to avoid collision with get
     make: { primary: 'yap', normalized: 'make' },
     clone: { primary: 'kopyala', normalized: 'clone' },
-    swap: { primary: 'değiştir', alternatives: ['takas'], normalized: 'swap' },
+    swap: { primary: 'takas', normalized: 'swap' }, // Removed değiştir alternative to avoid collision with toggle
     morph: { primary: 'dönüştür', alternatives: ['şekil değiştir'], normalized: 'morph' },
     // Variable operations
     set: { primary: 'ayarla', alternatives: ['yap', 'belirle'], normalized: 'set' },
@@ -79,8 +107,14 @@ export const turkishProfile: LanguageProfile = {
     trigger: { primary: 'tetikle', normalized: 'trigger' },
     send: { primary: 'gönder', normalized: 'send' },
     // DOM focus
-    focus: { primary: 'odak', normalized: 'focus' },
-    blur: { primary: 'bulanık', normalized: 'blur' },
+    focus: { primary: 'odak', alternatives: ['odaklanma'], normalized: 'focus' },
+    blur: { primary: 'bulanık', alternatives: ['bulanıklık'], normalized: 'blur' },
+    // Common event names (for event handler patterns)
+    click: { primary: 'tıklama', alternatives: ['tıkla'], normalized: 'click' },
+    hover: { primary: 'üzerine gelme', alternatives: ['üzerinde gezinme'], normalized: 'hover' },
+    submit: { primary: 'gönderme', alternatives: ['gönder'], normalized: 'submit' },
+    input: { primary: 'giriş', alternatives: ['girdi'], normalized: 'input' },
+    change: { primary: 'değişiklik', alternatives: ['değişim'], normalized: 'change' },
     // Navigation
     go: { primary: 'git', normalized: 'go' },
     // Async
@@ -119,6 +153,14 @@ export const turkishProfile: LanguageProfile = {
     // Event modifiers (for repeat until event)
     until: { primary: 'kadar', normalized: 'until' },
     event: { primary: 'olay', normalized: 'event' },
-    from: { primary: '-den', alternatives: ['-dan'], normalized: 'from' },
+    from: { primary: 'den', alternatives: ['dan'], normalized: 'from' },
+  },
+  eventHandler: {
+    // Event marker: da/de/ta/te (locative case suffix with vowel harmony), used in SOV pattern
+    // Pattern: [event] da [patient] i [action]
+    // Example: tıklama da .active i değiştir
+    // Note: Vowel harmony variants (da/de/ta/te) should be handled by vowel harmony expansion
+    eventMarker: { primary: 'da', alternatives: ['de', 'ta', 'te'], position: 'after' },
+    temporalMarkers: ['dığında', 'diğinde'], // temporal converb suffixes (when)
   },
 };

package/src/generators/profiles/types.ts

@@ -65,7 +65,7 @@ export interface PossessiveConfig {
  * Complete language profile for pattern generation.
  */
 export interface LanguageProfile {
-  /** ISO 639-1 language code */
+  /** ISO 639-1 or BCP 47 language code (e.g., 'es' or 'es-MX') */
   readonly code: string;
   /** Human-readable language name */
   readonly name: string;
@@ -104,19 +104,35 @@ export interface LanguageProfile {
    * Individual keywords can override this via KeywordTranslation.form
    */
   readonly defaultVerbForm?: VerbForm;
+  /**
+   * Base language code to extend (for regional variants).
+   * When set, this profile inherits from the base and overrides specific fields.
+   * Example: 'es-MX' profile with extends: 'es' inherits from Spanish base.
+   */
+  readonly extends?: string;
 }
 
 /**
  * Configuration for event handler pattern generation.
- * Used by simple SVO languages that don't need hand-crafted patterns.
+ * Supports both SVO and SOV/VSO languages.
  */
 export interface EventHandlerConfig {
-  /** Primary event keyword (e.g., 'on', 'bei', 'sur') */
-  readonly keyword: KeywordTranslation;
+  /** Primary event keyword (e.g., 'on', 'bei', 'sur') for SVO */
+  readonly keyword?: KeywordTranslation;
   /** Source filter marker (e.g., 'from', 'von', 'de') */
-  readonly sourceMarker: RoleMarker;
+  readonly sourceMarker?: RoleMarker;
   /** Conditional keyword (e.g., 'when', 'wenn', 'quand') */
   readonly conditionalKeyword?: KeywordTranslation;
+
+  /** Event marker for SOV/VSO languages (e.g., で (Japanese), 할 때 (Korean), da (Turkish), عند (Arabic)) */
+  readonly eventMarker?: RoleMarker;
+  /** Temporal/conditional markers that can optionally appear with events */
+  readonly temporalMarkers?: string[];
+  /**
+   * Negation marker for expressing negated events (e.g., Arabic عدم = "not/lack of").
+   * Used in patterns like: عند عدم التركيز = "when not focusing" = "on blur"
+   */
+  readonly negationMarker?: RoleMarker;
 }
 
 /**

package/src/generators/profiles/ukrainian.ts

@@ -173,6 +173,12 @@ export const ukrainianProfile: LanguageProfile = {
       normalized: 'blur',
       form: 'infinitive',
     },
+    // Common event names (for event handler patterns)
+    click: { primary: 'кліку', alternatives: ['клік', 'натисканні'], normalized: 'click' },
+    hover: { primary: 'наведенні', alternatives: ['наведення'], normalized: 'hover' },
+    submit: { primary: 'відправці', alternatives: ['відправка'], normalized: 'submit' },
+    input: { primary: 'введенні', alternatives: ['введення'], normalized: 'input' },
+    change: { primary: 'зміні', alternatives: ['зміна'], normalized: 'change' },
     // Navigation
     go: {
       primary: 'перейти',
@@ -266,5 +272,10 @@ export const ukrainianProfile: LanguageProfile = {
   eventHandler: {
     keyword: { primary: 'при', alternatives: ['коли'], normalized: 'on' },
     sourceMarker: { primary: 'на', alternatives: ['в', 'при'], position: 'before' },
+    // Event marker: при (at/on/upon), used in SVO pattern
+    // Pattern: при [event] [verb] [patient] на [destination?]
+    // Example: при кліку перемкнути .active на #button
+    eventMarker: { primary: 'при', alternatives: ['коли'], position: 'before' },
+    temporalMarkers: ['коли', 'якщо'], // temporal conjunctions (when, if)
   },
 };

package/src/generators/profiles/vietnamese.ts

@@ -86,6 +86,12 @@ export const vietnameseProfile: LanguageProfile = {
     // DOM focus
     focus: { primary: 'tập trung', normalized: 'focus' },
     blur: { primary: 'mất tập trung', normalized: 'blur' },
+    // Common event names (for event handler patterns)
+    click: { primary: 'nhấp', alternatives: ['bấm'], normalized: 'click' },
+    hover: { primary: 'di chuột', alternatives: ['rê chuột'], normalized: 'hover' },
+    submit: { primary: 'gửi', alternatives: ['nộp'], normalized: 'submit' },
+    input: { primary: 'nhập', alternatives: ['nhập liệu'], normalized: 'input' },
+    change: { primary: 'thay đổi', alternatives: ['đổi'], normalized: 'change' },
     // Navigation
     go: { primary: 'đi đến', alternatives: ['đi'], normalized: 'go' },
     // Async
@@ -129,5 +135,10 @@ export const vietnameseProfile: LanguageProfile = {
   eventHandler: {
     keyword: { primary: 'khi', alternatives: ['lúc', 'trên'], normalized: 'on' },
     sourceMarker: { primary: 'trên', alternatives: ['tại'], position: 'before' },
+    // Event marker: khi (when), used in SVO pattern
+    // Pattern: khi [event] [verb] [patient] vào [destination?]
+    // Example: khi nhấp chuyển đổi .active vào #button
+    eventMarker: { primary: 'khi', alternatives: ['lúc'], position: 'before' },
+    temporalMarkers: ['khi', 'lúc'], // temporal conjunctions (when)
   },
 };

package/src/language-building-schema.ts

@@ -1160,6 +1160,75 @@ export const SUPPORTED_LANGUAGES: LanguageChecklist[] = [
     missingFromTokenizer: [], // Now synced
     potentialConflicts: [],
   },
+  {
+    // ⚠️ TEST VARIANT - demonstrates language variant feature, not production-ready
+    code: 'es-MX',
+    name: 'Spanish (Mexico) [TEST]',
+    wordOrder: 'SVO',
+    direction: 'ltr',
+    files: {
+      languageProfile: true,
+      tokenizer: true, // Uses Spanish tokenizer via inheritance
+      tokenizerRegistered: true,
+      morphologicalNormalizer: true, // Uses Spanish normalizer
+      eventHandlerPatterns: true, // Uses Spanish patterns
+      tests: true,
+      morphologyTests: false,
+    },
+    morphology: {
+      needed: true,
+      reason: 'Example variant - uses Spanish morphology with illustrative Mexican vocabulary',
+      inflectionTypes: ['inherits from Spanish'],
+      integratedWithTokenizer: true,
+      confidenceThreshold: 0.7,
+    },
+    profileKeywords: [
+      'alternar',
+      'añadir',
+      'quitar',
+      'poner',
+      'establecer',
+      'mostrar',
+      'ocultar',
+      'añadir',
+      'anteponer',
+      'incrementar',
+      'decrementar',
+      'esperar',
+      'ahorita', // Mexican alternative for wait
+      'obtener',
+      'jalar', // Mexican alternative for fetch
+      'ir',
+      'disparar',
+      'enviar',
+      'registrar',
+      'tomar',
+      'hacer',
+      'clonar',
+      'enfocar',
+      'desenfocar',
+      'transición',
+      'estabilizar',
+      'llamar',
+      'devolver',
+      'aventar', // Mexican alternative for throw
+      'js',
+      'asíncrono',
+      'decir',
+      'predeterminar',
+      'iniciar',
+      'comportamiento',
+      'dentro de',
+      'antes',
+      'después',
+    ],
+    tokenizerKeywords: [
+      // Inherits Spanish tokenizer keywords
+      // Mexican-specific alternatives are in profile
+    ],
+    missingFromTokenizer: [],
+    potentialConflicts: [],
+  },
   {
     code: 'tr',
     name: 'Turkish',
@@ -2893,6 +2962,48 @@ export const SUPPORTED_LANGUAGES: LanguageChecklist[] = [
     missingFromTokenizer: [],
     potentialConflicts: [],
   },
+  {
+    code: 'he',
+    name: 'Hebrew',
+    wordOrder: 'SVO',
+    direction: 'rtl',
+    files: {
+      languageProfile: true,
+      tokenizer: true,
+      tokenizerRegistered: true,
+      morphologicalNormalizer: false,
+      eventHandlerPatterns: true,
+      tests: true,
+      morphologyTests: false,
+    },
+    morphology: {
+      needed: true,
+      reason: 'Hebrew has verb conjugation (binyanim) but commands use imperative/infinitive forms',
+      inflectionTypes: ['imperative form', 'infinitive form', 'binyanim patterns'],
+      integratedWithTokenizer: false,
+      confidenceThreshold: 0.7,
+    },
+    profileKeywords: ['החלף', 'הוסף', 'הסר', 'שים', 'קבע', 'הראה', 'הסתר', 'הגדל', 'הקטן'],
+    tokenizerKeywords: [
+      'החלף',
+      'שנה',
+      'הוסף',
+      'הסר',
+      'מחק',
+      'שים',
+      'הכנס',
+      'קבע',
+      'הגדר',
+      'קבל',
+      'הראה',
+      'הצג',
+      'הסתר',
+      'הגדל',
+      'הקטן',
+    ],
+    missingFromTokenizer: [],
+    potentialConflicts: [],
+  },
 ];
 
 /**

package/src/languages/_all.ts

@@ -1,7 +1,7 @@
 /**
  * All Languages Module
  *
- * Imports and registers all 23 supported languages.
+ * Imports and registers all 25 supported languages.
  * Use this for the full bundle with all language support.
  *
  * @example
@@ -20,7 +20,9 @@ import './bn';
 import './de';
 import './en';
 import './es';
+import './es-MX';
 import './fr';
+import './he';
 import './hi';
 import './id';
 import './it';
@@ -45,7 +47,9 @@ export * from './bn';
 export * from './de';
 export * from './en';
 export * from './es';
+export * from './es-MX';
 export * from './fr';
+export * from './he';
 export * from './hi';
 export * from './id';
 export * from './it';

package/src/languages/es-MX.ts

@@ -0,0 +1,32 @@
+/**
+ * Mexican Spanish Language Module
+ *
+ * Self-registering module for Mexican Spanish (es-MX) language support.
+ * Registers the Mexican Spanish profile with the base Spanish tokenizer.
+ *
+ * This demonstrates the language variant feature:
+ * - Reuses the Spanish tokenizer (Mexican Spanish has same tokenization rules)
+ * - Has its own profile with Mexican-specific keywords and alternatives
+ * - Profile extends 'es' for inheritance of common properties
+ *
+ * @example
+ * ```typescript
+ * // Import to register
+ * import '@lokascript/semantic/languages/es-MX';
+ *
+ * // Parse with Mexican Spanish
+ * parse('ahorita mostrar .loading', 'es-MX');  // "ahorita" is Mexican for "wait"
+ * parse('jalar datos de /api', 'es-MX');       // "jalar" is Mexican for "fetch/pull"
+ * ```
+ */
+
+import { registerLanguage } from '../registry';
+import { spanishTokenizer } from '../tokenizers/spanish';
+import { spanishMexicoProfile } from '../generators/profiles/spanishMexico';
+
+export { spanishMexicoProfile } from '../generators/profiles/spanishMexico';
+// Re-export Spanish tokenizer since we use it for es-MX
+export { spanishTokenizer } from '../tokenizers/spanish';
+
+// Register es-MX with the Mexican Spanish profile and Spanish tokenizer
+registerLanguage('es-MX', spanishTokenizer, spanishMexicoProfile);

package/src/languages/he.ts

@@ -0,0 +1,15 @@
+/**
+ * Hebrew Language Module
+ *
+ * Self-registering module for Hebrew language support.
+ * Importing this module registers Hebrew tokenizer and profile.
+ */
+
+import { registerLanguage } from '../registry';
+import { hebrewTokenizer } from '../tokenizers/he';
+import { hebrewProfile } from '../generators/profiles/hebrew';
+
+export { hebrewTokenizer } from '../tokenizers/he';
+export { hebrewProfile } from '../generators/profiles/hebrew';
+
+registerLanguage('he', hebrewTokenizer, hebrewProfile);

package/src/parser/pattern-matcher.ts

@@ -112,7 +112,16 @@ export class PatternMatcher {
     captured: Map<SemanticRole, SemanticValue>
   ): boolean {
     // Skip leading conjunctions for Arabic (proclitics: و, ف, ول, وب, etc.)
-    if (this.currentProfile?.code === 'ar') {
+    // BUT NOT if the pattern explicitly expects a conjunction (proclitic patterns)
+    const firstPatternToken = patternTokens[0];
+    const patternExpectsConjunction =
+      firstPatternToken?.type === 'literal' &&
+      (firstPatternToken.value === 'and' ||
+        firstPatternToken.value === 'then' ||
+        firstPatternToken.alternatives?.includes('and') ||
+        firstPatternToken.alternatives?.includes('then'));
+
+    if (this.currentProfile?.code === 'ar' && !patternExpectsConjunction) {
       while (tokens.peek()?.kind === 'conjunction') {
         tokens.advance();
       }

package/src/parser/semantic-parser.ts

@@ -106,6 +106,7 @@ export class SemanticParserImpl implements ISemanticParser {
     return createCommandNode(match.pattern.command, roles, {
       sourceLanguage: language,
       patternId: match.pattern.id,
+      confidence: match.confidence,
     });
   }
 
@@ -150,6 +151,7 @@ export class SemanticParserImpl implements ISemanticParser {
       const commandNode = createCommandNode(actionName as ActionType, roles, {
         sourceLanguage: language,
         patternId: match.pattern.id,
+        confidence: match.confidence,
       });
 
       // Check if pattern has continuation marker (then-chains)
@@ -195,6 +197,7 @@ export class SemanticParserImpl implements ISemanticParser {
     return createEventHandler(eventValue, body, eventModifiers, {
       sourceLanguage: language,
       patternId: match.pattern.id,
+      confidence: match.confidence,
     });
   }