@lokascript/semantic 1.3.0 → 2.0.0

package/src/generators/pattern-generator.ts

@@ -7,7 +7,7 @@
  */
 
 import type { LanguagePattern, PatternToken, ExtractionRule } from '../types';
-import type { LanguageProfile, KeywordTranslation, RoleMarker } from './language-profiles';
+import type { LanguageProfile } from './language-profiles';
 import type { CommandSchema, RoleSpec } from './command-schemas';
 import { getDefinedSchemas } from './command-schemas';
 
@@ -15,6 +15,26 @@ import { getDefinedSchemas } from './command-schemas';
 import { sortRolesByWordOrder } from '../parser/utils/role-positioning';
 import { resolveMarkerForRole } from '../parser/utils/marker-resolution';
 
+// Import word-order-specific event handler generators
+import {
+  generateSOVEventHandlerPattern,
+  generateSOVPatientFirstEventHandlerPattern,
+  generateSOVPatientFirstWithDestEventHandlerPattern,
+  generateSOVCompactEventHandlerPattern,
+  generateSOVSimpleEventHandlerPattern,
+  generateSOVTemporalEventHandlerPattern,
+  generateSOVTwoRoleEventHandlerPattern,
+  generateSOVTwoRoleDestFirstEventHandlerPattern,
+} from './event-handlers-sov';
+import {
+  generateVSOEventHandlerPattern,
+  generateVSOVerbFirstEventHandlerPattern,
+  generateVSOVerbFirstTwoRoleEventHandlerPattern,
+  generateVSOTwoRoleEventHandlerPattern,
+  generateVSONegatedEventHandlerPattern,
+  generateVSOProcliticEventHandlerPattern,
+} from './event-handlers-vso';
+
 // Note: languageProfiles is no longer imported here.
 // Pattern generation for specific languages uses the registry instead.
 
@@ -271,12 +291,25 @@ export function generateEventHandlerPatterns(
   // Generate pattern based on word order
   if (profile.wordOrder === 'SOV') {
     if (hasTwoRequiredRoles) {
-      // Two-role SOV pattern for put/set commands
+      // Two-role SOV pattern for put/set commands (event-first)
       // Japanese put: 入力 で "test" を #output に 入れる
       // Korean set: 변경 할 때 x 를 10 으로 설정
       patterns.push(
         generateSOVTwoRoleEventHandlerPattern(commandSchema, profile, keyword, eventMarker, config)
       );
+
+      // Two-role SOV pattern (destination-first variant)
+      // Bengali set: @disabled কে ক্লিক এ সেট সত্য তে
+      // Quechua set: x ta ñitiy pi 10 man churay
+      patterns.push(
+        generateSOVTwoRoleDestFirstEventHandlerPattern(
+          commandSchema,
+          profile,
+          keyword,
+          eventMarker,
+          config
+        )
+      );
     } else {
       // SOV: [event] [eventMarker] [destination? destMarker?] [patient] [patientMarker] [verb]
       // Japanese: クリック で #button の .active を 切り替え
@@ -286,6 +319,37 @@ export function generateEventHandlerPatterns(
         generateSOVEventHandlerPattern(commandSchema, profile, keyword, eventMarker, config)
       );
 
+      // Patient-first SOV variants: patient before event (common in Bengali, Quechua)
+      // Bengali: .active কে ক্লিক এ টগল  (patient + event + verb)
+      // Quechua: .highlight ta noqa man ñitiy pi yapay  (patient + dest + event + verb)
+      // Both orders are valid in SOV languages depending on topic/focus.
+
+      // Variant 1: Simple (no destination) — higher priority
+      patterns.push(
+        generateSOVPatientFirstEventHandlerPattern(
+          commandSchema,
+          profile,
+          keyword,
+          eventMarker,
+          config
+        )
+      );
+
+      // Variant 2: With destination (required, not optional) — lower priority
+      // Only add if destination marker differs from event marker to avoid collision
+      const destMarkerCheck = profile.roleMarkers.destination;
+      if (destMarkerCheck && destMarkerCheck.primary !== eventMarker.primary) {
+        patterns.push(
+          generateSOVPatientFirstWithDestEventHandlerPattern(
+            commandSchema,
+            profile,
+            keyword,
+            eventMarker,
+            config
+          )
+        );
+      }
+
       // For multi-word event markers with no-space alternatives (Korean compact forms),
       // also generate a pattern that accepts the compact form
       // Example: 클릭할때 .active를토글 (할때 as single token)
@@ -325,11 +389,23 @@ export function generateEventHandlerPatterns(
     }
   } else if (profile.wordOrder === 'VSO') {
     if (hasTwoRequiredRoles) {
-      // Two-role VSO pattern for put/set commands
+      // Two-role VSO pattern for put/set commands (event-first)
       // Arabic put: عند الإدخال ضع "test" في #output
       patterns.push(
         generateVSOTwoRoleEventHandlerPattern(commandSchema, profile, keyword, eventMarker, config)
       );
+
+      // Two-role VSO verb-first variant (event handler at end)
+      // Tagalog: itakda aking *background sa "red" kapag click
+      patterns.push(
+        generateVSOVerbFirstTwoRoleEventHandlerPattern(
+          commandSchema,
+          profile,
+          keyword,
+          eventMarker,
+          config
+        )
+      );
     } else {
       // VSO: [eventMarker] [event] [verb] [patient] [على destination?]
       // Arabic: عند النقر بدّل .active على #button
@@ -337,6 +413,19 @@ export function generateEventHandlerPatterns(
         generateVSOEventHandlerPattern(commandSchema, profile, keyword, eventMarker, config)
       );
 
+      // VSO verb-first variant: [verb] [patient] [eventMarker] [event]
+      // Tagalog: alisin ako kapag click (remove me on click)
+      // Tagalog: palitan .active kapag click (toggle .active on click)
+      patterns.push(
+        generateVSOVerbFirstEventHandlerPattern(
+          commandSchema,
+          profile,
+          keyword,
+          eventMarker,
+          config
+        )
+      );
+
       // Add negated event pattern variant for languages with negation markers
       // Pattern: [eventMarker] [negation] [event] [verb] [patient]
       // Example: عند عدم التركيز أخف #tooltip = "on blur hide #tooltip"
@@ -377,738 +466,6 @@ export function generateEventHandlerPatterns(
   return patterns;
 }
 
-/**
- * Generate SOV event handler pattern (Japanese, Korean, Turkish).
- */
-function generateSOVEventHandlerPattern(
-  commandSchema: CommandSchema,
-  profile: LanguageProfile,
-  keyword: KeywordTranslation,
-  eventMarker: RoleMarker,
-  config: GeneratorConfig
-): LanguagePattern {
-  const tokens: PatternToken[] = [];
-
-  // Event role
-  tokens.push({ type: 'role', role: 'event', optional: false });
-
-  // Event marker (after event in SOV)
-  // Handle multi-word markers like Korean "할 때" by splitting into separate tokens
-  if (eventMarker.position === 'after') {
-    const markerWords = eventMarker.primary.split(/\s+/);
-    if (markerWords.length > 1) {
-      // Multi-word marker: create a token for each word
-      for (const word of markerWords) {
-        tokens.push({ type: 'literal', value: word });
-      }
-    } else {
-      // Single-word marker: include alternatives
-      const markerToken: PatternToken = eventMarker.alternatives
-        ? { type: 'literal', value: eventMarker.primary, alternatives: eventMarker.alternatives }
-        : { type: 'literal', value: eventMarker.primary };
-      tokens.push(markerToken);
-    }
-  }
-
-  // Optional destination with its marker
-  const destMarker = profile.roleMarkers.destination;
-  if (destMarker) {
-    tokens.push({
-      type: 'group',
-      optional: true,
-      tokens: [
-        { type: 'role', role: 'destination', optional: true },
-        destMarker.alternatives
-          ? { type: 'literal', value: destMarker.primary, alternatives: destMarker.alternatives }
-          : { type: 'literal', value: destMarker.primary },
-      ],
-    });
-  }
-
-  // Patient role
-  tokens.push({ type: 'role', role: 'patient', optional: false });
-
-  // Patient marker (postposition/particle after patient)
-  const patientMarker = profile.roleMarkers.patient;
-  if (patientMarker) {
-    const patMarkerToken: PatternToken = patientMarker.alternatives
-      ? { type: 'literal', value: patientMarker.primary, alternatives: patientMarker.alternatives }
-      : { type: 'literal', value: patientMarker.primary };
-    tokens.push(patMarkerToken);
-  }
-
-  // Command verb at end (SOV)
-  const verbToken: PatternToken = keyword.alternatives
-    ? { type: 'literal', value: keyword.primary, alternatives: keyword.alternatives }
-    : { type: 'literal', value: keyword.primary };
-  tokens.push(verbToken);
-
-  return {
-    id: `${commandSchema.action}-event-${profile.code}-sov`,
-    language: profile.code,
-    command: 'on', // This is an event handler pattern
-    priority: (config.basePriority ?? 100) + 50, // Higher priority than simple commands
-    template: {
-      format: `{event} ${eventMarker.primary} {destination?} {patient} ${patientMarker?.primary || ''} ${keyword.primary}`,
-      tokens,
-    },
-    extraction: {
-      action: { value: commandSchema.action }, // Extract the wrapped command
-      event: { fromRole: 'event' },
-      patient: { fromRole: 'patient' },
-      destination: { fromRole: 'destination', default: { type: 'reference', value: 'me' } },
-    },
-  };
-}
-
-/**
- * Generate SOV compact event handler pattern for languages with no-space forms.
- *
- * This handles Korean compact forms where the event marker is attached directly
- * to the event word without a space:
- * - 클릭할때 .active를토글 (click+when toggle .active)
- *
- * The pattern uses a single token for the no-space marker alternatives.
- */
-function generateSOVCompactEventHandlerPattern(
-  commandSchema: CommandSchema,
-  profile: LanguageProfile,
-  keyword: KeywordTranslation,
-  eventMarker: RoleMarker,
-  config: GeneratorConfig
-): LanguagePattern {
-  const tokens: PatternToken[] = [];
-
-  // Event role
-  tokens.push({ type: 'role', role: 'event', optional: false });
-
-  // Event marker as single token (using no-space alternatives)
-  // Filter alternatives to only include no-space versions
-  const noSpaceAlternatives =
-    eventMarker.alternatives?.filter(alt => !alt.includes(' ') && alt.length > 1) || [];
-
-  if (noSpaceAlternatives.length > 0) {
-    tokens.push({
-      type: 'literal',
-      value: noSpaceAlternatives[0],
-      alternatives: noSpaceAlternatives.slice(1),
-    });
-  }
-
-  // Optional destination with its marker
-  const destMarker = profile.roleMarkers.destination;
-  if (destMarker) {
-    tokens.push({
-      type: 'group',
-      optional: true,
-      tokens: [
-        { type: 'role', role: 'destination', optional: true },
-        destMarker.alternatives
-          ? { type: 'literal', value: destMarker.primary, alternatives: destMarker.alternatives }
-          : { type: 'literal', value: destMarker.primary },
-      ],
-    });
-  }
-
-  // Patient role
-  tokens.push({ type: 'role', role: 'patient', optional: false });
-
-  // Patient marker (postposition/particle after patient)
-  const patientMarker = profile.roleMarkers.patient;
-  if (patientMarker) {
-    const patMarkerToken: PatternToken = patientMarker.alternatives
-      ? { type: 'literal', value: patientMarker.primary, alternatives: patientMarker.alternatives }
-      : { type: 'literal', value: patientMarker.primary };
-    tokens.push(patMarkerToken);
-  }
-
-  // Command verb at end (SOV)
-  const verbToken: PatternToken = keyword.alternatives
-    ? { type: 'literal', value: keyword.primary, alternatives: keyword.alternatives }
-    : { type: 'literal', value: keyword.primary };
-  tokens.push(verbToken);
-
-  return {
-    id: `${commandSchema.action}-event-${profile.code}-sov-compact`,
-    language: profile.code,
-    command: 'on', // This is an event handler pattern
-    priority: (config.basePriority ?? 100) + 52, // Slightly higher priority for compact forms
-    template: {
-      format: `{event}${noSpaceAlternatives[0] || ''} {patient} ${keyword.primary}`,
-      tokens,
-    },
-    extraction: {
-      action: { value: commandSchema.action }, // Extract the wrapped command
-      event: { fromRole: 'event' },
-      patient: { fromRole: 'patient' },
-      destination: { fromRole: 'destination', default: { type: 'reference', value: 'me' } },
-    },
-  };
-}
-
-/**
- * Generate SOV simple event handler pattern (patient optional, defaults to 'me').
- *
- * Supports patterns like:
- * - Japanese: クリック で 増加 (click on increment)
- * - Korean: 클릭 할 때 증가 (click when increment)
- * - Turkish: tıklama da artır (click on increment)
- *
- * The patient is not explicitly specified - it defaults to 'me' (current element).
- */
-function generateSOVSimpleEventHandlerPattern(
-  commandSchema: CommandSchema,
-  profile: LanguageProfile,
-  keyword: KeywordTranslation,
-  eventMarker: RoleMarker,
-  config: GeneratorConfig
-): LanguagePattern {
-  const tokens: PatternToken[] = [];
-
-  // Event role
-  tokens.push({ type: 'role', role: 'event', optional: false });
-
-  // Event marker (after event in SOV)
-  if (eventMarker.position === 'after') {
-    const markerWords = eventMarker.primary.split(/\s+/);
-    if (markerWords.length > 1) {
-      // Multi-word marker: create a token for each word
-      for (const word of markerWords) {
-        tokens.push({ type: 'literal', value: word });
-      }
-    } else {
-      const markerToken: PatternToken = eventMarker.alternatives
-        ? { type: 'literal', value: eventMarker.primary, alternatives: eventMarker.alternatives }
-        : { type: 'literal', value: eventMarker.primary };
-      tokens.push(markerToken);
-    }
-  }
-
-  // Command verb at end (SOV) - no patient required
-  const verbToken: PatternToken = keyword.alternatives
-    ? { type: 'literal', value: keyword.primary, alternatives: keyword.alternatives }
-    : { type: 'literal', value: keyword.primary };
-  tokens.push(verbToken);
-
-  return {
-    id: `${commandSchema.action}-event-${profile.code}-sov-simple`,
-    language: profile.code,
-    command: 'on',
-    priority: (config.basePriority ?? 100) + 48, // Lower than full pattern (50) but higher than base
-    template: {
-      format: `{event} ${eventMarker.primary} ${keyword.primary}`,
-      tokens,
-    },
-    extraction: {
-      action: { value: commandSchema.action },
-      event: { fromRole: 'event' },
-      patient: { default: { type: 'reference', value: 'me' } }, // Default to 'me'
-    },
-  };
-}
-
-/**
- * Generate SOV temporal event handler pattern.
- *
- * Supports patterns with temporal markers like:
- * - Japanese: クリック 時 .active を 切り替え (click time toggle .active)
- * - Japanese: クリック の 時 .active を 切り替え (click's time toggle .active)
- *
- * Uses profile.eventHandler.temporalMarkers for language-specific temporal words.
- */
-function generateSOVTemporalEventHandlerPattern(
-  commandSchema: CommandSchema,
-  profile: LanguageProfile,
-  keyword: KeywordTranslation,
-  config: GeneratorConfig
-): LanguagePattern | null {
-  const temporalMarkers = profile.eventHandler?.temporalMarkers;
-  if (!temporalMarkers || temporalMarkers.length === 0) return null;
-
-  const tokens: PatternToken[] = [];
-
-  // Event role
-  tokens.push({ type: 'role', role: 'event', optional: false });
-
-  // Optional possessive marker (の in Japanese)
-  if (profile.possessive?.marker) {
-    tokens.push({
-      type: 'group',
-      optional: true,
-      tokens: [{ type: 'literal', value: profile.possessive.marker }],
-    });
-  }
-
-  // Temporal marker (時, とき in Japanese)
-  tokens.push({
-    type: 'literal',
-    value: temporalMarkers[0],
-    alternatives: temporalMarkers.slice(1),
-  });
-
-  // Patient role
-  tokens.push({ type: 'role', role: 'patient', optional: false });
-
-  // Patient marker
-  const patientMarker = profile.roleMarkers.patient;
-  if (patientMarker?.primary) {
-    const patMarkerToken: PatternToken = patientMarker.alternatives
-      ? { type: 'literal', value: patientMarker.primary, alternatives: patientMarker.alternatives }
-      : { type: 'literal', value: patientMarker.primary };
-    tokens.push(patMarkerToken);
-  }
-
-  // Command verb at end
-  const verbToken: PatternToken = keyword.alternatives
-    ? { type: 'literal', value: keyword.primary, alternatives: keyword.alternatives }
-    : { type: 'literal', value: keyword.primary };
-  tokens.push(verbToken);
-
-  return {
-    id: `${commandSchema.action}-event-${profile.code}-sov-temporal`,
-    language: profile.code,
-    command: 'on',
-    priority: (config.basePriority ?? 100) + 49, // Between simple and full pattern
-    template: {
-      format: `{event} ${temporalMarkers[0]} {patient} ${keyword.primary}`,
-      tokens,
-    },
-    extraction: {
-      action: { value: commandSchema.action },
-      event: { fromRole: 'event' },
-      patient: { fromRole: 'patient' },
-    },
-  };
-}
-
-/**
- * Generate VSO event handler pattern (Arabic).
- */
-function generateVSOEventHandlerPattern(
-  commandSchema: CommandSchema,
-  profile: LanguageProfile,
-  keyword: KeywordTranslation,
-  eventMarker: RoleMarker,
-  config: GeneratorConfig
-): LanguagePattern {
-  const tokens: PatternToken[] = [];
-
-  // Event marker (before event in VSO)
-  if (eventMarker.position === 'before') {
-    const markerToken: PatternToken = eventMarker.alternatives
-      ? { type: 'literal', value: eventMarker.primary, alternatives: eventMarker.alternatives }
-      : { type: 'literal', value: eventMarker.primary };
-    tokens.push(markerToken);
-  }
-
-  // Event role
-  tokens.push({ type: 'role', role: 'event', optional: false });
-
-  // Command verb (verb comes early in VSO)
-  const verbToken: PatternToken = keyword.alternatives
-    ? { type: 'literal', value: keyword.primary, alternatives: keyword.alternatives }
-    : { type: 'literal', value: keyword.primary };
-  tokens.push(verbToken);
-
-  // Patient role
-  tokens.push({ type: 'role', role: 'patient', optional: false });
-
-  // Optional destination with preposition
-  const destMarker = profile.roleMarkers.destination;
-  if (destMarker) {
-    tokens.push({
-      type: 'group',
-      optional: true,
-      tokens: [
-        destMarker.alternatives
-          ? { type: 'literal', value: destMarker.primary, alternatives: destMarker.alternatives }
-          : { type: 'literal', value: destMarker.primary },
-        { type: 'role', role: 'destination', optional: true },
-      ],
-    });
-  }
-
-  return {
-    id: `${commandSchema.action}-event-${profile.code}-vso`,
-    language: profile.code,
-    command: 'on', // This is an event handler pattern
-    priority: (config.basePriority ?? 100) + 50, // Higher priority than simple commands
-    template: {
-      format: `${eventMarker.primary} {event} ${keyword.primary} {patient} ${destMarker?.primary || ''} {destination?}`,
-      tokens,
-    },
-    extraction: {
-      action: { value: commandSchema.action }, // Extract the wrapped command
-      event: { fromRole: 'event' },
-      patient: { fromRole: 'patient' },
-      destination: { fromRole: 'destination', default: { type: 'reference', value: 'me' } },
-    },
-  };
-}
-
-/**
- * Generate SOV two-role event handler pattern (for put/set commands).
- *
- * Patterns:
- * - Japanese put: 入力 で "test" を #output に 入れる
- *   [event] [eventMarker] [patient] [patientMarker] [destination] [destMarker] [verb]
- * - Korean set: 변경 할 때 x 를 10 으로 설정
- *   [event] [eventMarker] [role1] [role1Marker] [role2] [role2Marker] [verb]
- * - Turkish put: giriş de "test" i #output a koy
- *   [event] [eventMarker] [patient] [patientMarker] [destination] [destMarker] [verb]
- */
-function generateSOVTwoRoleEventHandlerPattern(
-  commandSchema: CommandSchema,
-  profile: LanguageProfile,
-  keyword: KeywordTranslation,
-  eventMarker: RoleMarker,
-  config: GeneratorConfig
-): LanguagePattern {
-  const tokens: PatternToken[] = [];
-
-  // Event role
-  tokens.push({ type: 'role', role: 'event', optional: false });
-
-  // Event marker (after event in SOV)
-  // Handle multi-word markers like Korean "할 때" by splitting into separate tokens
-  if (eventMarker.position === 'after') {
-    const markerWords = eventMarker.primary.split(/\s+/);
-    if (markerWords.length > 1) {
-      // Multi-word marker: create a token for each word
-      for (const word of markerWords) {
-        tokens.push({ type: 'literal', value: word });
-      }
-    } else {
-      // Single-word marker: include alternatives
-      const markerToken: PatternToken = eventMarker.alternatives
-        ? { type: 'literal', value: eventMarker.primary, alternatives: eventMarker.alternatives }
-        : { type: 'literal', value: eventMarker.primary };
-      tokens.push(markerToken);
-    }
-  }
-
-  // Get the two required roles from the schema
-  const requiredRoles = commandSchema.roles.filter(r => r.required);
-
-  // Sort by SOV position (lower number = earlier in sentence)
-  const sortedRoles = [...requiredRoles].sort((a, b) => {
-    const aPos = a.sovPosition ?? 999;
-    const bPos = b.sovPosition ?? 999;
-    return aPos - bPos;
-  });
-
-  // Add each role with its marker
-  for (const roleSpec of sortedRoles) {
-    // Add the role
-    tokens.push({ type: 'role', role: roleSpec.role, optional: false });
-
-    // Get marker for this role - check for override first
-    let marker: string | undefined;
-    let markerAlternatives: string[] | undefined;
-
-    if (roleSpec.markerOverride && roleSpec.markerOverride[profile.code]) {
-      // Use the override marker
-      marker = roleSpec.markerOverride[profile.code];
-    } else {
-      // Use default role marker from profile
-      const roleMarker = profile.roleMarkers[roleSpec.role];
-      if (roleMarker) {
-        marker = roleMarker.primary;
-        markerAlternatives = roleMarker.alternatives;
-      }
-    }
-
-    // Add the marker token
-    if (marker) {
-      const markerToken: PatternToken = markerAlternatives
-        ? { type: 'literal', value: marker, alternatives: markerAlternatives }
-        : { type: 'literal', value: marker };
-      tokens.push(markerToken);
-    }
-  }
-
-  // Command verb at end (SOV)
-  const verbToken: PatternToken = keyword.alternatives
-    ? { type: 'literal', value: keyword.primary, alternatives: keyword.alternatives }
-    : { type: 'literal', value: keyword.primary };
-  tokens.push(verbToken);
-
-  // Build format string
-  const roleNames = sortedRoles.map(r => `{${r.role}}`).join(' ');
-
-  return {
-    id: `${commandSchema.action}-event-${profile.code}-sov-2role`,
-    language: profile.code,
-    command: 'on', // This is an event handler pattern
-    priority: (config.basePriority ?? 100) + 55, // Higher priority than single-role patterns
-    template: {
-      format: `{event} ${eventMarker.primary} ${roleNames} ${keyword.primary}`,
-      tokens,
-    },
-    extraction: {
-      action: { value: commandSchema.action }, // Extract the wrapped command
-      event: { fromRole: 'event' },
-      patient: { fromRole: 'patient' },
-      destination: { fromRole: 'destination' },
-    },
-  };
-}
-
-/**
- * Generate VSO two-role event handler pattern (for put/set commands).
- *
- * Patterns:
- * - Arabic put: عند الإدخال ضع "test" في #output
- *   [eventMarker] [event] [verb] [patient] [destPrep] [destination]
- * - Arabic set: عند التغيير عيّن x إلى 10
- *   [eventMarker] [event] [verb] [destination] [patientPrep] [patient]
- */
-function generateVSOTwoRoleEventHandlerPattern(
-  commandSchema: CommandSchema,
-  profile: LanguageProfile,
-  keyword: KeywordTranslation,
-  eventMarker: RoleMarker,
-  config: GeneratorConfig
-): LanguagePattern {
-  const tokens: PatternToken[] = [];
-
-  // Event marker (before event in VSO)
-  if (eventMarker.position === 'before') {
-    const markerToken: PatternToken = eventMarker.alternatives
-      ? { type: 'literal', value: eventMarker.primary, alternatives: eventMarker.alternatives }
-      : { type: 'literal', value: eventMarker.primary };
-    tokens.push(markerToken);
-  }
-
-  // Event role
-  tokens.push({ type: 'role', role: 'event', optional: false });
-
-  // Command verb (verb comes early in VSO)
-  const verbToken: PatternToken = keyword.alternatives
-    ? { type: 'literal', value: keyword.primary, alternatives: keyword.alternatives }
-    : { type: 'literal', value: keyword.primary };
-  tokens.push(verbToken);
-
-  // Get the two required roles from the schema
-  const requiredRoles = commandSchema.roles.filter(r => r.required);
-
-  // Sort by SVO position for VSO (role order is similar)
-  const sortedRoles = [...requiredRoles].sort((a, b) => {
-    const aPos = a.svoPosition ?? 999;
-    const bPos = b.svoPosition ?? 999;
-    return aPos - bPos;
-  });
-
-  // Add each role with its preposition/marker
-  for (const roleSpec of sortedRoles) {
-    // Get marker for this role - check for override first
-    let marker: string | undefined;
-    let markerAlternatives: string[] | undefined;
-
-    if (roleSpec.markerOverride && roleSpec.markerOverride[profile.code]) {
-      // Use the override marker
-      marker = roleSpec.markerOverride[profile.code];
-    } else {
-      // Use default role marker from profile
-      const roleMarker = profile.roleMarkers[roleSpec.role];
-      if (roleMarker) {
-        marker = roleMarker.primary;
-        markerAlternatives = roleMarker.alternatives;
-      }
-    }
-
-    // In VSO, prepositions come BEFORE the noun (prepositional languages)
-    if (marker) {
-      const markerToken: PatternToken = markerAlternatives
-        ? { type: 'literal', value: marker, alternatives: markerAlternatives }
-        : { type: 'literal', value: marker };
-      tokens.push(markerToken);
-    }
-
-    // Add the role
-    tokens.push({ type: 'role', role: roleSpec.role, optional: false });
-  }
-
-  // Build format string
-  const roleNames = sortedRoles.map(r => `{${r.role}}`).join(' ');
-
-  return {
-    id: `${commandSchema.action}-event-${profile.code}-vso-2role`,
-    language: profile.code,
-    command: 'on', // This is an event handler pattern
-    priority: (config.basePriority ?? 100) + 55, // Higher priority than single-role patterns
-    template: {
-      format: `${eventMarker.primary} {event} ${keyword.primary} ${roleNames}`,
-      tokens,
-    },
-    extraction: {
-      action: { value: commandSchema.action }, // Extract the wrapped command
-      event: { fromRole: 'event' },
-      patient: { fromRole: 'patient' },
-      destination: { fromRole: 'destination' },
-    },
-  };
-}
-
-/**
- * Generate VSO negated event handler pattern.
- *
- * Patterns:
- * - Arabic: عند عدم التركيز أخف #tooltip
- *   [eventMarker] [negation] [event] [verb] [patient]
- *
- * Used for events expressed as negation + opposite action:
- * - عدم التركيز = "not focusing" = blur
- */
-function generateVSONegatedEventHandlerPattern(
-  commandSchema: CommandSchema,
-  profile: LanguageProfile,
-  keyword: KeywordTranslation,
-  eventMarker: RoleMarker,
-  config: GeneratorConfig
-): LanguagePattern {
-  const tokens: PatternToken[] = [];
-  const negationMarker = profile.eventHandler?.negationMarker;
-
-  // Event marker (before event in VSO)
-  if (eventMarker.position === 'before') {
-    const markerToken: PatternToken = eventMarker.alternatives
-      ? { type: 'literal', value: eventMarker.primary, alternatives: eventMarker.alternatives }
-      : { type: 'literal', value: eventMarker.primary };
-    tokens.push(markerToken);
-  }
-
-  // Negation marker (e.g., عدم = "not/lack of")
-  if (negationMarker) {
-    const negToken: PatternToken = negationMarker.alternatives
-      ? {
-          type: 'literal',
-          value: negationMarker.primary,
-          alternatives: negationMarker.alternatives,
-        }
-      : { type: 'literal', value: negationMarker.primary };
-    tokens.push(negToken);
-  }
-
-  // Event role (the action being negated, e.g., التركيز = "the focusing")
-  tokens.push({ type: 'role', role: 'event', optional: false });
-
-  // Command verb (verb comes early in VSO)
-  const verbToken: PatternToken = keyword.alternatives
-    ? { type: 'literal', value: keyword.primary, alternatives: keyword.alternatives }
-    : { type: 'literal', value: keyword.primary };
-  tokens.push(verbToken);
-
-  // Patient role
-  tokens.push({ type: 'role', role: 'patient', optional: false });
-
-  // Optional destination with preposition
-  const destMarker = profile.roleMarkers.destination;
-  if (destMarker) {
-    tokens.push({
-      type: 'group',
-      optional: true,
-      tokens: [
-        destMarker.alternatives
-          ? { type: 'literal', value: destMarker.primary, alternatives: destMarker.alternatives }
-          : { type: 'literal', value: destMarker.primary },
-        { type: 'role', role: 'destination', optional: true },
-      ],
-    });
-  }
-
-  return {
-    id: `${commandSchema.action}-event-${profile.code}-vso-negated`,
-    language: profile.code,
-    command: 'on', // This is an event handler pattern
-    priority: (config.basePriority ?? 100) + 48, // Slightly lower priority than standard patterns
-    template: {
-      format: `${eventMarker.primary} ${negationMarker?.primary || ''} {event} ${keyword.primary} {patient} ${destMarker?.primary || ''} {destination?}`,
-      tokens,
-    },
-    extraction: {
-      action: { value: commandSchema.action }, // Extract the wrapped command
-      event: { fromRole: 'event' },
-      patient: { fromRole: 'patient' },
-      destination: { fromRole: 'destination', default: { type: 'reference', value: 'me' } },
-    },
-  };
-}
-
-/**
- * Generate VSO proclitic event handler pattern (for Arabic chained events).
- *
- * Patterns:
- * - Arabic: والنقر بدّل .active
- *   [proclitic] [event] [verb] [patient]
- * - Arabic: فالتحويم أضف .highlight
- *   [proclitic] [event] [verb] [patient]
- *
- * These patterns have a conjunction proclitic (و = and, ف = then) attached to
- * the event, without the عند event marker. Used for chained/consequent events.
- */
-function generateVSOProcliticEventHandlerPattern(
-  commandSchema: CommandSchema,
-  profile: LanguageProfile,
-  keyword: KeywordTranslation,
-  config: GeneratorConfig
-): LanguagePattern {
-  const tokens: PatternToken[] = [];
-
-  // Required conjunction token (و = and, ف = then)
-  // The conjunction must be present for this pattern - it distinguishes chained events from regular commands
-  // Use normalized values since proclitics are tokenized as conjunction tokens
-  tokens.push({
-    type: 'literal',
-    value: 'and', // Matches normalized 'and' (Arabic: و)
-    alternatives: ['then'], // Also matches normalized 'then' (Arabic: ف)
-  });
-
-  // Event role (the event name, e.g., النقر = the click)
-  tokens.push({ type: 'role', role: 'event', optional: false });
-
-  // Command verb (verb comes early in VSO)
-  const verbToken: PatternToken = keyword.alternatives
-    ? { type: 'literal', value: keyword.primary, alternatives: keyword.alternatives }
-    : { type: 'literal', value: keyword.primary };
-  tokens.push(verbToken);
-
-  // Patient role
-  tokens.push({ type: 'role', role: 'patient', optional: false });
-
-  // Optional destination with preposition
-  const destMarker = profile.roleMarkers.destination;
-  if (destMarker) {
-    tokens.push({
-      type: 'group',
-      optional: true,
-      tokens: [
-        destMarker.alternatives
-          ? { type: 'literal', value: destMarker.primary, alternatives: destMarker.alternatives }
-          : { type: 'literal', value: destMarker.primary },
-        { type: 'role', role: 'destination', optional: true },
-      ],
-    });
-  }
-
-  return {
-    id: `${commandSchema.action}-event-${profile.code}-vso-proclitic`,
-    language: profile.code,
-    command: 'on', // This is an event handler pattern
-    priority: (config.basePriority ?? 100) + 45, // Lower priority than standard patterns
-    template: {
-      format: `[proclitic?] {event} ${keyword.primary} {patient} ${destMarker?.primary || ''} {destination?}`,
-      tokens,
-    },
-    extraction: {
-      action: { value: commandSchema.action }, // Extract the wrapped command
-      event: { fromRole: 'event' },
-      patient: { fromRole: 'patient' },
-      destination: { fromRole: 'destination', default: { type: 'reference', value: 'me' } },
-    },
-  };
-}
-
 // =============================================================================
 // Token Building
 // =============================================================================
@@ -1202,7 +559,7 @@ function buildRoleToken(roleSpec: RoleSpec, profile: LanguageProfile): PatternTo
     type: 'role',
     role: roleSpec.role,
     optional: !roleSpec.required,
-    expectedTypes: roleSpec.expectedTypes as any,
+    expectedTypes: roleSpec.expectedTypes,
   };
 
   // Use override marker if available, otherwise use default