@lokascript/semantic 1.2.1 → 2.0.0

package/dist/languages/en.js

@@ -324,8 +324,12 @@ var init_schema_validator = __esm({
       "measure",
       "return",
       "swap",
-      "morph"
+      "morph",
       // DOM manipulation commands that accept various content types
+      "beep",
+      // Debug command — accepts any expression type
+      "copy"
+      // Clipboard — accepts text literals, selectors, or references
     ]);
     NO_REQUIRED_ROLES_COMMANDS = /* @__PURE__ */ new Set([
       "compound",
@@ -339,8 +343,14 @@ var init_schema_validator = __esm({
       "blur",
       "return",
       "js",
-      "measure"
+      "measure",
       // Commands with optional-only roles
+      "break",
+      // Zero-arg control flow (exit loop)
+      "exit",
+      // Zero-arg control flow (exit handler)
+      "beep"
+      // Debug command — all roles optional
     ]);
   }
 });
@@ -360,7 +370,7 @@ function registerPatterns(code, patterns) {
   patternCache.delete(code);
 }
 
-// src/tokenizers/base.ts
+// src/tokenizers/token-utils.ts
 var TokenStreamImpl = class {
   constructor(tokens, language) {
     this.pos = 0;
@@ -426,17 +436,14 @@ function createToken(value, kind, position, normalizedOrOptions) {
   }
   if (normalizedOrOptions) {
     const { normalized, stem, stemConfidence } = normalizedOrOptions;
-    const token = { value, kind, position };
-    if (normalized !== void 0) {
-      token.normalized = normalized;
-    }
-    if (stem !== void 0) {
-      token.stem = stem;
-      if (stemConfidence !== void 0) {
-        token.stemConfidence = stemConfidence;
-      }
-    }
-    return token;
+    return {
+      value,
+      kind,
+      position,
+      ...normalized !== void 0 && { normalized },
+      ...stem !== void 0 && { stem },
+      ...stemConfidence !== void 0 && { stemConfidence }
+    };
   }
   return { value, kind, position };
 }
@@ -458,6 +465,8 @@ function isAsciiLetter(char) {
 function isAsciiIdentifierChar(char) {
   return /[a-zA-Z0-9_-]/.test(char);
 }
+
+// src/tokenizers/extractors.ts
 function extractCssSelector(input, startPos) {
   if (startPos >= input.length) return null;
   const char = input[startPos];
@@ -715,6 +724,8 @@ function extractNumber(input, startPos) {
   }
   return number;
 }
+
+// src/tokenizers/base-tokenizer.ts
 var _BaseTokenizer = class _BaseTokenizer {
   constructor() {
     /** Keywords derived from profile, sorted longest-first for greedy matching */
@@ -722,6 +733,34 @@ var _BaseTokenizer = class _BaseTokenizer {
     /** Map for O(1) keyword lookups by lowercase native word */
     this.profileKeywordMap = /* @__PURE__ */ new Map();
   }
+  /**
+   * Check if current position is a property access (obj.prop) vs CSS selector (.active).
+   * Property access: no whitespace before '.', previous token is identifier/keyword/selector.
+   * Also detects standalone method calls: .identifier( pattern.
+   *
+   * Returns true if '.' was emitted as an operator token and pos should advance by 1.
+   * Returns false if this is a CSS selector and should be handled by trySelector().
+   */
+  tryPropertyAccess(input, pos, tokens) {
+    if (input[pos] !== ".") return false;
+    const lastToken = tokens[tokens.length - 1];
+    const hasWhitespaceBefore = lastToken && lastToken.position.end < pos;
+    const isPropertyAccess = lastToken && !hasWhitespaceBefore && (lastToken.kind === "identifier" || lastToken.kind === "keyword" || lastToken.kind === "selector");
+    if (isPropertyAccess) {
+      tokens.push(createToken(".", "operator", createPosition(pos, pos + 1)));
+      return true;
+    }
+    const methodStart = pos + 1;
+    let methodEnd = methodStart;
+    while (methodEnd < input.length && isAsciiIdentifierChar(input[methodEnd])) {
+      methodEnd++;
+    }
+    if (methodEnd < input.length && input[methodEnd] === "(") {
+      tokens.push(createToken(".", "operator", createPosition(pos, pos + 1)));
+      return true;
+    }
+    return false;
+  }
   /**
    * Initialize keyword mappings from a language profile.
    * Builds a list of native→english mappings from:
@@ -757,6 +796,11 @@ var _BaseTokenizer = class _BaseTokenizer {
       for (const [normalized, native] of Object.entries(profile.references)) {
         keywordMap.set(native, { native, normalized });
       }
+      for (const canonical of Object.keys(profile.references)) {
+        if (!keywordMap.has(canonical)) {
+          keywordMap.set(canonical, { native: canonical, normalized: canonical });
+        }
+      }
     }
     if (profile.roleMarkers) {
       for (const [role, marker] of Object.entries(profile.roleMarkers)) {
@@ -1222,6 +1266,12 @@ var englishProfile = {
     behavior: { primary: "behavior" },
     install: { primary: "install" },
     measure: { primary: "measure" },
+    beep: { primary: "beep" },
+    break: { primary: "break" },
+    copy: { primary: "copy" },
+    exit: { primary: "exit" },
+    pick: { primary: "pick" },
+    render: { primary: "render" },
     into: { primary: "into" },
     before: { primary: "before" },
     after: { primary: "after" },
@@ -1434,7 +1484,8 @@ var EnglishTokenizer = class extends BaseTokenizer {
   }
   classifyToken(token) {
     if (this.isKeyword(token)) return "keyword";
-    if (token.startsWith("#") || token.startsWith(".") || token.startsWith("[")) return "selector";
+    if (token.startsWith("#") || token.startsWith(".") || token.startsWith("[") || token.startsWith("*") || token.startsWith("<"))
+      return "selector";
     if (token.startsWith('"') || token.startsWith("'")) return "literal";
     if (/^\d/.test(token)) return "literal";
     if (["==", "!=", "<=", ">=", "<", ">", "&&", "||", "!"].includes(token)) return "operator";
@@ -1576,7 +1627,9 @@ var addSchema = {
       expectedTypes: ["selector", "reference"],
       default: { type: "reference", value: "me" },
       svoPosition: 2,
-      sovPosition: 1
+      sovPosition: 1,
+      markerOverride: { en: "to" }
+      // "add .class to #element"
     }
   ],
   // Runtime error documentation
@@ -1653,8 +1706,10 @@ var putSchema = {
       required: true,
       expectedTypes: ["selector", "reference"],
       svoPosition: 2,
-      sovPosition: 2
+      sovPosition: 2,
       // SOV: destination comes second (に/에/a marker)
+      markerOverride: { en: "into" }
+      // "put 'hello' into #output"
     }
   ],
   // Runtime error documentation
@@ -1717,8 +1772,16 @@ var setSchema = {
         // "x 를 10 으로 설정" - variable gets object marker
         tr: "i",
         // "x i 10 e ayarla" - variable gets accusative marker
-        ar: ""
+        ar: "",
         // "عيّن x إلى 10" - no marker before variable
+        sw: "",
+        // "seti x kwenye 10" - no marker before variable
+        tl: "",
+        // "itakda x sa 10" - no marker before variable
+        bn: "\u0995\u09C7",
+        // "x কে 10 তে সেট" - patient marker on variable
+        qu: "ta"
+        // "x ta 10 man churay" - patient marker on variable
       }
     },
     {
@@ -1750,8 +1813,16 @@ var setSchema = {
         // "x 를 10 으로 설정" - value gets manner/instrument marker
         tr: "e",
         // "x i 10 e ayarla" - value gets dative marker
-        ar: "\u0625\u0644\u0649"
+        ar: "\u0625\u0644\u0649",
         // "عيّن x إلى 10" - value gets preposition "to"
+        sw: "kwenye",
+        // "seti x kwenye 10" - destination prep before value
+        tl: "sa",
+        // "itakda x sa 10" - destination prep before value
+        bn: "\u09A4\u09C7",
+        // "x কে 10 তে সেট" - destination marker on value
+        qu: "man"
+        // "x ta 10 man churay" - destination marker on value
       }
     }
   ],
@@ -1913,7 +1984,10 @@ var fetchSchema = {
       required: true,
       expectedTypes: ["literal", "expression"],
       svoPosition: 1,
-      sovPosition: 1
+      sovPosition: 1,
+      // No markerOverride — uses profile default 'from' for parsing.
+      renderOverride: { en: "" }
+      // "fetch /api" (rendering — no preposition)
     },
     {
       role: "responseType",
@@ -1963,7 +2037,9 @@ var incrementSchema = {
       expectedTypes: ["literal"],
       default: { type: "literal", value: 1, dataType: "number" },
       svoPosition: 2,
-      sovPosition: 2
+      sovPosition: 2,
+      markerOverride: { en: "by" }
+      // "increment :count by 5"
     }
   ]
 };
@@ -1988,7 +2064,9 @@ var decrementSchema = {
       expectedTypes: ["literal"],
       default: { type: "literal", value: 1, dataType: "number" },
       svoPosition: 2,
-      sovPosition: 2
+      sovPosition: 2,
+      markerOverride: { en: "by" }
+      // "decrement :count by 5"
     }
   ]
 };
@@ -2012,7 +2090,9 @@ var appendSchema = {
       required: true,
       expectedTypes: ["selector", "reference"],
       svoPosition: 2,
-      sovPosition: 1
+      sovPosition: 1,
+      markerOverride: { en: "to" }
+      // "append <content> to #element"
     }
   ]
 };
@@ -2036,7 +2116,9 @@ var prependSchema = {
       required: true,
       expectedTypes: ["selector", "reference"],
       svoPosition: 2,
-      sovPosition: 1
+      sovPosition: 1,
+      markerOverride: { en: "to" }
+      // "prepend <content> to #element"
     }
   ]
 };
@@ -2086,7 +2168,15 @@ var getCommandSchema = {
         // Arabic preposition: احصل على #element
         tr: "i",
         // Turkish accusative: #element i al
-        id: ""
+        id: "",
+        sw: "",
+        // Swahili SVO: pata #element (no marker)
+        tl: "",
+        // Tagalog VSO: kunin #element (no marker)
+        bn: "\u0995\u09C7",
+        // Bengali SOV: #element কে পান (patient marker)
+        qu: "ta"
+        // Quechua SOV: #element ta taripay (patient marker)
       }
     },
     {
@@ -2338,7 +2428,9 @@ var forSchema = {
       required: true,
       expectedTypes: ["selector", "reference", "expression"],
       svoPosition: 2,
-      sovPosition: 1
+      sovPosition: 1,
+      markerOverride: { en: "in" }
+      // "for item in .items"
     }
   ]
 };
@@ -2379,7 +2471,11 @@ var goSchema = {
       required: true,
       expectedTypes: ["literal", "expression"],
       svoPosition: 1,
-      sovPosition: 1
+      sovPosition: 1,
+      markerOverride: { en: "to" },
+      // "go to /page" (parsing)
+      renderOverride: { en: "" }
+      // "go /page" (rendering — no preposition)
     }
   ]
 };
@@ -2396,7 +2492,10 @@ var transitionSchema = {
       expectedTypes: ["literal"],
       // Only literal - CSS properties are strings, not selectors
       svoPosition: 1,
-      sovPosition: 2
+      sovPosition: 2,
+      // No marker before the CSS property name (SVO/VSO languages)
+      // SOV languages (bn, qu) use their default patient marker from profile
+      markerOverride: { en: "", ar: "", tl: "", sw: "" }
     },
     {
       role: "goal",
@@ -2404,7 +2503,24 @@ var transitionSchema = {
       required: true,
       expectedTypes: ["literal", "expression"],
       svoPosition: 2,
-      sovPosition: 3
+      sovPosition: 3,
+      // "to" preposition before goal value (same as set's patient marker)
+      markerOverride: {
+        en: "to",
+        ar: "\u0625\u0644\u0649",
+        tl: "sa",
+        sw: "kwenye",
+        bn: "\u09A4\u09C7",
+        qu: "man",
+        es: "a",
+        pt: "para",
+        fr: "\xE0",
+        de: "auf",
+        ja: "\u306B",
+        ko: "\uC73C\uB85C",
+        tr: "e",
+        id: "ke"
+      }
     },
     {
       role: "destination",
@@ -2421,7 +2537,9 @@ var transitionSchema = {
       required: false,
       expectedTypes: ["literal"],
       svoPosition: 4,
-      sovPosition: 4
+      sovPosition: 4,
+      markerOverride: { en: "over" }
+      // "transition opacity to 1 over 500ms"
     },
     {
       role: "style",
@@ -2453,7 +2571,9 @@ var cloneSchema = {
       required: false,
       expectedTypes: ["selector", "reference"],
       svoPosition: 2,
-      sovPosition: 1
+      sovPosition: 1,
+      markerOverride: { en: "into" }
+      // "clone #element into #container"
     }
   ]
 };
@@ -2561,7 +2681,9 @@ var tellSchema = {
       required: true,
       expectedTypes: ["selector", "reference"],
       svoPosition: 1,
-      sovPosition: 1
+      sovPosition: 1,
+      markerOverride: { en: "" }
+      // "tell #element ..." (no preposition)
     }
   ]
 };
@@ -2577,7 +2699,16 @@ var defaultSchema = {
       required: true,
       expectedTypes: ["reference"],
       svoPosition: 1,
-      sovPosition: 1
+      sovPosition: 1,
+      // Same overrides as SET: no marker before variable in VSO/SVO
+      markerOverride: {
+        en: "",
+        ar: "",
+        tl: "",
+        sw: "",
+        bn: "\u0995\u09C7",
+        qu: "ta"
+      }
     },
     {
       role: "patient",
@@ -2585,7 +2716,16 @@ var defaultSchema = {
       required: true,
       expectedTypes: ["literal", "expression"],
       svoPosition: 2,
-      sovPosition: 2
+      sovPosition: 2,
+      // Same overrides as SET: value gets destination preposition
+      markerOverride: {
+        en: "to",
+        ar: "\u0625\u0644\u0649",
+        tl: "sa",
+        sw: "kwenye",
+        bn: "\u09A4\u09C7",
+        qu: "man"
+      }
     }
   ]
 };
@@ -2662,7 +2802,9 @@ var measureSchema = {
       expectedTypes: ["selector", "reference"],
       default: { type: "reference", value: "me" },
       svoPosition: 2,
-      sovPosition: 2
+      sovPosition: 2,
+      markerOverride: { en: "of" }
+      // "measure width of #element"
     }
   ]
 };
@@ -2678,7 +2820,9 @@ var swapSchema = {
       required: false,
       expectedTypes: ["literal"],
       svoPosition: 1,
-      sovPosition: 3
+      sovPosition: 3,
+      markerOverride: { en: "" }
+      // "swap innerHTML ..." (no preposition)
     },
     {
       role: "destination",
@@ -2686,7 +2830,9 @@ var swapSchema = {
       required: true,
       expectedTypes: ["selector", "reference"],
       svoPosition: 2,
-      sovPosition: 1
+      sovPosition: 1,
+      markerOverride: { en: "of" }
+      // "swap innerHTML of #target"
     },
     {
       role: "patient",
@@ -2694,7 +2840,9 @@ var swapSchema = {
       required: false,
       expectedTypes: ["literal", "expression", "selector"],
       svoPosition: 3,
-      sovPosition: 2
+      sovPosition: 2,
+      markerOverride: { en: "with" }
+      // "swap innerHTML of #target with <html>"
     }
   ]
 };
@@ -2710,7 +2858,9 @@ var morphSchema = {
       required: true,
       expectedTypes: ["selector", "reference"],
       svoPosition: 1,
-      sovPosition: 1
+      sovPosition: 1,
+      markerOverride: { en: "" }
+      // "morph #target ..." (no preposition)
     },
     {
       role: "patient",
@@ -2718,7 +2868,103 @@ var morphSchema = {
       required: true,
       expectedTypes: ["literal", "expression", "selector"],
       svoPosition: 2,
+      sovPosition: 2,
+      markerOverride: { en: "to" }
+      // "morph #target to <html>"
+    }
+  ]
+};
+var beepSchema = {
+  action: "beep",
+  description: "Debug output for expressions with type information",
+  category: "variable",
+  primaryRole: "patient",
+  roles: [
+    {
+      role: "patient",
+      description: "The expression(s) to debug",
+      required: false,
+      expectedTypes: ["literal", "selector", "reference", "expression"],
+      svoPosition: 1,
+      sovPosition: 1
+    }
+  ]
+};
+var breakSchema = {
+  action: "break",
+  description: "Exit from the current loop",
+  category: "control-flow",
+  primaryRole: "patient",
+  roles: []
+};
+var copySchema = {
+  action: "copy",
+  description: "Copy text or element content to the clipboard",
+  category: "dom-content",
+  primaryRole: "patient",
+  roles: [
+    {
+      role: "patient",
+      description: "The text or element to copy",
+      required: true,
+      expectedTypes: ["literal", "selector", "reference", "expression"],
+      svoPosition: 1,
+      sovPosition: 1
+    }
+  ]
+};
+var exitSchema = {
+  action: "exit",
+  description: "Exit from the current event handler",
+  category: "control-flow",
+  primaryRole: "patient",
+  roles: []
+};
+var pickSchema = {
+  action: "pick",
+  description: "Select a random element from a collection",
+  category: "variable",
+  primaryRole: "patient",
+  roles: [
+    {
+      role: "patient",
+      description: "The items to pick from",
+      required: true,
+      expectedTypes: ["literal", "expression", "reference"],
+      svoPosition: 1,
+      sovPosition: 1
+    },
+    {
+      role: "source",
+      description: 'The array to pick from (with "from" keyword)',
+      required: false,
+      expectedTypes: ["reference", "expression"],
+      svoPosition: 2,
+      sovPosition: 2
+    }
+  ]
+};
+var renderSchema = {
+  action: "render",
+  description: "Render a template with optional variables",
+  category: "dom-content",
+  primaryRole: "patient",
+  roles: [
+    {
+      role: "patient",
+      description: "The template to render",
+      required: true,
+      expectedTypes: ["selector", "reference", "expression"],
+      svoPosition: 1,
       sovPosition: 2
+    },
+    {
+      role: "style",
+      description: "Variables to pass to the template (with keyword)",
+      required: false,
+      expectedTypes: ["expression", "reference"],
+      svoPosition: 2,
+      sovPosition: 1
     }
   ]
 };
@@ -2776,6 +3022,13 @@ var commandSchemas = {
   // Batch 5 - DOM Content Manipulation
   swap: swapSchema,
   morph: morphSchema,
+  // Batch 6 - Missing Commands
+  beep: beepSchema,
+  break: breakSchema,
+  copy: copySchema,
+  exit: exitSchema,
+  pick: pickSchema,
+  render: renderSchema,
   // Meta commands (for compound structures)
   compound: {
     action: "compound",
@@ -2839,170 +3092,114 @@ function resolveMarkerForRole(roleSpec, profile) {
   return null;
 }
 
-// src/generators/pattern-generator.ts
-var defaultConfig = {
-  basePriority: 100,
-  generateSimpleVariants: true,
-  generateAlternatives: true
-};
-function generatePattern(schema, profile, config = defaultConfig) {
-  const id = `${schema.action}-${profile.code}-generated`;
-  const priority = config.basePriority ?? 100;
-  const keyword = profile.keywords[schema.action];
-  if (!keyword) {
-    throw new Error(`No keyword translation for '${schema.action}' in ${profile.code}`);
+// src/generators/event-handlers-sov.ts
+function generateSOVEventHandlerPattern(commandSchema, profile, keyword, eventMarker, config) {
+  const tokens = [];
+  tokens.push({ type: "role", role: "event", optional: false });
+  if (eventMarker.position === "after") {
+    const markerWords = eventMarker.primary.split(/\s+/);
+    if (markerWords.length > 1) {
+      for (const word of markerWords) {
+        tokens.push({ type: "literal", value: word });
+      }
+    } else {
+      const markerToken = eventMarker.alternatives ? { type: "literal", value: eventMarker.primary, alternatives: eventMarker.alternatives } : { type: "literal", value: eventMarker.primary };
+      tokens.push(markerToken);
+    }
   }
-  const tokens = buildTokens(schema, profile, keyword);
-  const extraction = buildExtractionRulesWithDefaults(schema, profile);
-  const format = buildFormatString(schema, profile, keyword);
+  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 }
+      ]
+    });
+  }
+  tokens.push({ type: "role", role: "patient", optional: false });
+  const patientMarker = profile.roleMarkers.patient;
+  if (patientMarker) {
+    const patMarkerToken = patientMarker.alternatives ? { type: "literal", value: patientMarker.primary, alternatives: patientMarker.alternatives } : { type: "literal", value: patientMarker.primary };
+    tokens.push(patMarkerToken);
+  }
+  const verbToken = keyword.alternatives ? { type: "literal", value: keyword.primary, alternatives: keyword.alternatives } : { type: "literal", value: keyword.primary };
+  tokens.push(verbToken);
   return {
-    id,
+    id: `${commandSchema.action}-event-${profile.code}-sov`,
     language: profile.code,
-    command: schema.action,
-    priority,
+    command: "on",
+    // This is an event handler pattern
+    priority: (config.basePriority ?? 100) + 50,
+    // Higher priority than simple commands
     template: {
-      format,
+      format: `{event} ${eventMarker.primary} {destination?} {patient} ${patientMarker?.primary || ""} ${keyword.primary}`,
       tokens
     },
-    extraction
+    extraction: {
+      action: { value: commandSchema.action },
+      // Extract the wrapped command
+      event: { fromRole: "event" },
+      patient: { fromRole: "patient" },
+      destination: { fromRole: "destination", default: { type: "reference", value: "me" } }
+    }
   };
 }
-function generateSimplePattern(schema, profile, config = defaultConfig) {
-  const optionalRoles = schema.roles.filter((r) => !r.required);
-  if (optionalRoles.length === 0) {
-    return null;
+function generateSOVPatientFirstEventHandlerPattern(commandSchema, profile, keyword, eventMarker, config) {
+  const tokens = [];
+  tokens.push({ type: "role", role: "patient", optional: false });
+  const patientMarker = profile.roleMarkers.patient;
+  if (patientMarker) {
+    const patMarkerToken = patientMarker.alternatives ? { type: "literal", value: patientMarker.primary, alternatives: patientMarker.alternatives } : { type: "literal", value: patientMarker.primary };
+    tokens.push(patMarkerToken);
   }
-  const requiredRoles = schema.roles.filter((r) => r.required);
-  const simpleSchema = {
-    ...schema,
-    roles: requiredRoles
-  };
-  const pattern = generatePattern(simpleSchema, profile, config);
+  tokens.push({ type: "role", role: "event", optional: false });
+  if (eventMarker.position === "after") {
+    const markerWords = eventMarker.primary.split(/\s+/);
+    if (markerWords.length > 1) {
+      for (const word of markerWords) {
+        tokens.push({ type: "literal", value: word });
+      }
+    } else {
+      const markerToken = eventMarker.alternatives ? { type: "literal", value: eventMarker.primary, alternatives: eventMarker.alternatives } : { type: "literal", value: eventMarker.primary };
+      tokens.push(markerToken);
+    }
+  }
+  const verbToken = keyword.alternatives ? { type: "literal", value: keyword.primary, alternatives: keyword.alternatives } : { type: "literal", value: keyword.primary };
+  tokens.push(verbToken);
   return {
-    ...pattern,
-    id: `${schema.action}-${profile.code}-simple`,
-    priority: (config.basePriority ?? 100) - 5,
-    // Lower priority than full pattern (was -10)
-    extraction: buildExtractionRulesWithDefaults(schema, profile)
+    id: `${commandSchema.action}-event-${profile.code}-sov-patient-first`,
+    language: profile.code,
+    command: "on",
+    priority: (config.basePriority ?? 100) + 45,
+    template: {
+      format: `{patient} ${patientMarker?.primary || ""} {event} ${eventMarker.primary} ${keyword.primary}`,
+      tokens
+    },
+    extraction: {
+      action: { value: commandSchema.action },
+      event: { fromRole: "event" },
+      patient: { fromRole: "patient" },
+      destination: { fromRole: "destination", default: { type: "reference", value: "me" } }
+    }
   };
 }
-function generatePatternVariants(schema, profile, config = defaultConfig) {
-  const patterns = [];
-  patterns.push(generatePattern(schema, profile, config));
-  if (config.generateSimpleVariants) {
-    const simple = generateSimplePattern(schema, profile, config);
-    if (simple) {
-      patterns.push(simple);
-    }
-  }
-  return patterns;
-}
-function generatePatternsForLanguage(profile, config = defaultConfig) {
-  const patterns = [];
-  const schemas = getDefinedSchemas();
-  for (const schema of schemas) {
-    if (!profile.keywords[schema.action]) {
-      continue;
-    }
-    const variants = generatePatternVariants(schema, profile, config);
-    patterns.push(...variants);
-    if (profile.eventHandler?.eventMarker) {
-      const eventHandlerPatterns = generateEventHandlerPatterns(schema, profile, config);
-      patterns.push(...eventHandlerPatterns);
-    }
-  }
-  return patterns;
-}
-function generateEventHandlerPatterns(commandSchema, profile, config = defaultConfig) {
-  if (!profile.eventHandler || !profile.eventHandler.eventMarker) {
-    return [];
-  }
-  const patterns = [];
-  const eventMarker = profile.eventHandler.eventMarker;
-  const keyword = profile.keywords[commandSchema.action];
-  if (!keyword) {
-    return [];
+function generateSOVPatientFirstWithDestEventHandlerPattern(commandSchema, profile, keyword, eventMarker, config) {
+  const tokens = [];
+  tokens.push({ type: "role", role: "patient", optional: false });
+  const patientMarker = profile.roleMarkers.patient;
+  if (patientMarker) {
+    const patMarkerToken = patientMarker.alternatives ? { type: "literal", value: patientMarker.primary, alternatives: patientMarker.alternatives } : { type: "literal", value: patientMarker.primary };
+    tokens.push(patMarkerToken);
   }
-  const requiredRoles = commandSchema.roles.filter((r) => r.required);
-  const hasTwoRequiredRoles = requiredRoles.length === 2;
-  if (profile.wordOrder === "SOV") {
-    if (hasTwoRequiredRoles) {
-      patterns.push(
-        generateSOVTwoRoleEventHandlerPattern(commandSchema, profile, keyword, eventMarker, config)
-      );
-    } else {
-      patterns.push(
-        generateSOVEventHandlerPattern(commandSchema, profile, keyword, eventMarker, config)
-      );
-      const markerWords = eventMarker.primary.split(/\s+/);
-      const hasNoSpaceAlternative = eventMarker.alternatives?.some(
-        (alt) => !alt.includes(" ") && alt.length > 1
-      );
-      if (markerWords.length > 1 && hasNoSpaceAlternative) {
-        patterns.push(
-          generateSOVCompactEventHandlerPattern(
-            commandSchema,
-            profile,
-            keyword,
-            eventMarker,
-            config
-          )
-        );
-      }
-      patterns.push(
-        generateSOVSimpleEventHandlerPattern(commandSchema, profile, keyword, eventMarker, config)
-      );
-      const temporalPattern = generateSOVTemporalEventHandlerPattern(
-        commandSchema,
-        profile,
-        keyword,
-        config
-      );
-      if (temporalPattern) {
-        patterns.push(temporalPattern);
-      }
-    }
-  } else if (profile.wordOrder === "VSO") {
-    if (hasTwoRequiredRoles) {
-      patterns.push(
-        generateVSOTwoRoleEventHandlerPattern(commandSchema, profile, keyword, eventMarker, config)
-      );
-    } else {
-      patterns.push(
-        generateVSOEventHandlerPattern(commandSchema, profile, keyword, eventMarker, config)
-      );
-      if (profile.eventHandler?.negationMarker) {
-        patterns.push(
-          generateVSONegatedEventHandlerPattern(
-            commandSchema,
-            profile,
-            keyword,
-            eventMarker,
-            config
-          )
-        );
-      }
-      if (profile.tokenization?.prefixes) {
-        patterns.push(
-          generateVSOProcliticEventHandlerPattern(commandSchema, profile, keyword, config)
-        );
-      }
-    }
-  } else {
-    if (hasTwoRequiredRoles) {
-      patterns.push(
-        generateVSOTwoRoleEventHandlerPattern(commandSchema, profile, keyword, eventMarker, config)
-      );
-    } else {
-      patterns.push(
-        generateVSOEventHandlerPattern(commandSchema, profile, keyword, eventMarker, config)
-      );
-    }
+  const destMarker = profile.roleMarkers.destination;
+  if (destMarker) {
+    tokens.push({ type: "role", role: "destination", optional: false });
+    tokens.push(
+      destMarker.alternatives ? { type: "literal", value: destMarker.primary, alternatives: destMarker.alternatives } : { type: "literal", value: destMarker.primary }
+    );
   }
-  return patterns;
-}
-function generateSOVEventHandlerPattern(commandSchema, profile, keyword, eventMarker, config) {
-  const tokens = [];
   tokens.push({ type: "role", role: "event", optional: false });
   if (eventMarker.position === "after") {
     const markerWords = eventMarker.primary.split(/\s+/);
@@ -3015,42 +3212,23 @@ function generateSOVEventHandlerPattern(commandSchema, profile, keyword, eventMa
       tokens.push(markerToken);
     }
   }
-  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 }
-      ]
-    });
-  }
-  tokens.push({ type: "role", role: "patient", optional: false });
-  const patientMarker = profile.roleMarkers.patient;
-  if (patientMarker) {
-    const patMarkerToken = patientMarker.alternatives ? { type: "literal", value: patientMarker.primary, alternatives: patientMarker.alternatives } : { type: "literal", value: patientMarker.primary };
-    tokens.push(patMarkerToken);
-  }
   const verbToken = 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`,
+    id: `${commandSchema.action}-event-${profile.code}-sov-patient-first-dest`,
     language: profile.code,
     command: "on",
-    // This is an event handler pattern
-    priority: (config.basePriority ?? 100) + 50,
-    // Higher priority than simple commands
+    priority: (config.basePriority ?? 100) + 40,
+    // Lower than simple patient-first
     template: {
-      format: `{event} ${eventMarker.primary} {destination?} {patient} ${patientMarker?.primary || ""} ${keyword.primary}`,
+      format: `{patient} ${patientMarker?.primary || ""} {destination} ${destMarker?.primary || ""} {event} ${eventMarker.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" } }
+      destination: { fromRole: "destination" }
     }
   };
 }
@@ -3180,6 +3358,137 @@ function generateSOVTemporalEventHandlerPattern(commandSchema, profile, keyword,
     }
   };
 }
+function generateSOVTwoRoleEventHandlerPattern(commandSchema, profile, keyword, eventMarker, config) {
+  const tokens = [];
+  tokens.push({ type: "role", role: "event", optional: false });
+  if (eventMarker.position === "after") {
+    const markerWords = eventMarker.primary.split(/\s+/);
+    if (markerWords.length > 1) {
+      for (const word of markerWords) {
+        tokens.push({ type: "literal", value: word });
+      }
+    } else {
+      const markerToken = eventMarker.alternatives ? { type: "literal", value: eventMarker.primary, alternatives: eventMarker.alternatives } : { type: "literal", value: eventMarker.primary };
+      tokens.push(markerToken);
+    }
+  }
+  const requiredRoles = commandSchema.roles.filter((r) => r.required);
+  const sortedRoles = [...requiredRoles].sort((a, b) => {
+    const aPos = a.sovPosition ?? 999;
+    const bPos = b.sovPosition ?? 999;
+    return aPos - bPos;
+  });
+  for (const roleSpec of sortedRoles) {
+    tokens.push({ type: "role", role: roleSpec.role, optional: false });
+    let marker;
+    let markerAlternatives;
+    if (roleSpec.markerOverride && roleSpec.markerOverride[profile.code] !== void 0) {
+      marker = roleSpec.markerOverride[profile.code];
+    } else {
+      const roleMarker = profile.roleMarkers[roleSpec.role];
+      if (roleMarker) {
+        marker = roleMarker.primary;
+        markerAlternatives = roleMarker.alternatives;
+      }
+    }
+    if (marker) {
+      const markerToken = markerAlternatives ? { type: "literal", value: marker, alternatives: markerAlternatives } : { type: "literal", value: marker };
+      tokens.push(markerToken);
+    }
+  }
+  const verbToken = keyword.alternatives ? { type: "literal", value: keyword.primary, alternatives: keyword.alternatives } : { type: "literal", value: keyword.primary };
+  tokens.push(verbToken);
+  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" },
+      ...Object.fromEntries(sortedRoles.map((r) => [r.role, { fromRole: r.role }]))
+    }
+  };
+}
+function generateSOVTwoRoleDestFirstEventHandlerPattern(commandSchema, profile, keyword, eventMarker, config) {
+  const tokens = [];
+  const requiredRoles = commandSchema.roles.filter((r) => r.required);
+  const sortedRoles = [...requiredRoles].sort((a, b) => {
+    const aPos = a.sovPosition ?? 999;
+    const bPos = b.sovPosition ?? 999;
+    return aPos - bPos;
+  });
+  const firstRole = sortedRoles[0];
+  tokens.push({ type: "role", role: firstRole.role, optional: false });
+  let firstMarker;
+  if (firstRole.markerOverride && firstRole.markerOverride[profile.code] !== void 0) {
+    firstMarker = firstRole.markerOverride[profile.code];
+  } else {
+    const roleMarker = profile.roleMarkers[firstRole.role];
+    if (roleMarker) firstMarker = roleMarker.primary;
+  }
+  if (firstMarker) {
+    tokens.push({ type: "literal", value: firstMarker });
+  }
+  tokens.push({ type: "role", role: "event", optional: false });
+  if (eventMarker.position === "after") {
+    const markerWords = eventMarker.primary.split(/\s+/);
+    if (markerWords.length > 1) {
+      for (const word of markerWords) {
+        tokens.push({ type: "literal", value: word });
+      }
+    } else {
+      const markerToken = eventMarker.alternatives ? { type: "literal", value: eventMarker.primary, alternatives: eventMarker.alternatives } : { type: "literal", value: eventMarker.primary };
+      tokens.push(markerToken);
+    }
+  }
+  const verbToken = keyword.alternatives ? { type: "literal", value: keyword.primary, alternatives: keyword.alternatives } : { type: "literal", value: keyword.primary };
+  tokens.push(verbToken);
+  const secondRole = sortedRoles[1];
+  tokens.push({ type: "role", role: secondRole.role, optional: false });
+  let secondMarker;
+  let secondMarkerAlts;
+  if (secondRole.markerOverride && secondRole.markerOverride[profile.code] !== void 0) {
+    secondMarker = secondRole.markerOverride[profile.code];
+  } else {
+    const roleMarker = profile.roleMarkers[secondRole.role];
+    if (roleMarker) {
+      secondMarker = roleMarker.primary;
+      secondMarkerAlts = roleMarker.alternatives;
+    }
+  }
+  if (secondMarker) {
+    const markerToken = secondMarkerAlts ? { type: "literal", value: secondMarker, alternatives: secondMarkerAlts } : { type: "literal", value: secondMarker };
+    tokens.push(markerToken);
+  }
+  return {
+    id: `${commandSchema.action}-event-${profile.code}-sov-2role-dest-first`,
+    language: profile.code,
+    command: "on",
+    priority: (config.basePriority ?? 100) + 48,
+    // Slightly lower than event-first two-role
+    template: {
+      format: `{${firstRole.role}} {event} ${eventMarker.primary} ${keyword.primary} {${secondRole.role}}`,
+      tokens
+    },
+    extraction: {
+      action: { value: commandSchema.action },
+      event: { fromRole: "event" },
+      [firstRole.role]: { fromRole: firstRole.role },
+      [secondRole.role]: { fromRole: secondRole.role }
+    }
+  };
+}
+
+// src/generators/event-handlers-vso.ts
 function generateVSOEventHandlerPattern(commandSchema, profile, keyword, eventMarker, config) {
   const tokens = [];
   if (eventMarker.position === "before") {
@@ -3221,31 +3530,59 @@ function generateVSOEventHandlerPattern(commandSchema, profile, keyword, eventMa
     }
   };
 }
-function generateSOVTwoRoleEventHandlerPattern(commandSchema, profile, keyword, eventMarker, config) {
+function generateVSOVerbFirstEventHandlerPattern(commandSchema, profile, keyword, eventMarker, config) {
   const tokens = [];
+  const verbToken = keyword.alternatives ? { type: "literal", value: keyword.primary, alternatives: keyword.alternatives } : { type: "literal", value: keyword.primary };
+  tokens.push(verbToken);
+  tokens.push({ type: "role", role: "patient", optional: false });
+  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 }
+      ]
+    });
+  }
+  if (eventMarker.position === "before") {
+    const markerToken = eventMarker.alternatives ? { type: "literal", value: eventMarker.primary, alternatives: eventMarker.alternatives } : { type: "literal", value: eventMarker.primary };
+    tokens.push(markerToken);
+  }
   tokens.push({ type: "role", role: "event", optional: false });
-  if (eventMarker.position === "after") {
-    const markerWords = eventMarker.primary.split(/\s+/);
-    if (markerWords.length > 1) {
-      for (const word of markerWords) {
-        tokens.push({ type: "literal", value: word });
-      }
-    } else {
-      const markerToken = eventMarker.alternatives ? { type: "literal", value: eventMarker.primary, alternatives: eventMarker.alternatives } : { type: "literal", value: eventMarker.primary };
-      tokens.push(markerToken);
+  return {
+    id: `${commandSchema.action}-event-${profile.code}-vso-verb-first`,
+    language: profile.code,
+    command: "on",
+    priority: (config.basePriority ?? 100) + 45,
+    // Slightly lower than event-first variant
+    template: {
+      format: `${keyword.primary} {patient} ${destMarker?.primary || ""} {destination?} ${eventMarker.primary} {event}`,
+      tokens
+    },
+    extraction: {
+      action: { value: commandSchema.action },
+      event: { fromRole: "event" },
+      patient: { fromRole: "patient" },
+      destination: { fromRole: "destination", default: { type: "reference", value: "me" } }
     }
-  }
+  };
+}
+function generateVSOVerbFirstTwoRoleEventHandlerPattern(commandSchema, profile, keyword, eventMarker, config) {
+  const tokens = [];
+  const verbToken = keyword.alternatives ? { type: "literal", value: keyword.primary, alternatives: keyword.alternatives } : { type: "literal", value: keyword.primary };
+  tokens.push(verbToken);
   const requiredRoles = commandSchema.roles.filter((r) => r.required);
   const sortedRoles = [...requiredRoles].sort((a, b) => {
-    const aPos = a.sovPosition ?? 999;
-    const bPos = b.sovPosition ?? 999;
+    const aPos = a.svoPosition ?? 999;
+    const bPos = b.svoPosition ?? 999;
     return aPos - bPos;
   });
   for (const roleSpec of sortedRoles) {
-    tokens.push({ type: "role", role: roleSpec.role, optional: false });
     let marker;
     let markerAlternatives;
-    if (roleSpec.markerOverride && roleSpec.markerOverride[profile.code]) {
+    if (roleSpec.markerOverride && roleSpec.markerOverride[profile.code] !== void 0) {
       marker = roleSpec.markerOverride[profile.code];
     } else {
       const roleMarker = profile.roleMarkers[roleSpec.role];
@@ -3258,27 +3595,27 @@ function generateSOVTwoRoleEventHandlerPattern(commandSchema, profile, keyword,
       const markerToken = markerAlternatives ? { type: "literal", value: marker, alternatives: markerAlternatives } : { type: "literal", value: marker };
       tokens.push(markerToken);
     }
+    tokens.push({ type: "role", role: roleSpec.role, optional: false });
   }
-  const verbToken = keyword.alternatives ? { type: "literal", value: keyword.primary, alternatives: keyword.alternatives } : { type: "literal", value: keyword.primary };
-  tokens.push(verbToken);
+  if (eventMarker.position === "before") {
+    const markerToken = eventMarker.alternatives ? { type: "literal", value: eventMarker.primary, alternatives: eventMarker.alternatives } : { type: "literal", value: eventMarker.primary };
+    tokens.push(markerToken);
+  }
+  tokens.push({ type: "role", role: "event", optional: false });
   const roleNames = sortedRoles.map((r) => `{${r.role}}`).join(" ");
   return {
-    id: `${commandSchema.action}-event-${profile.code}-sov-2role`,
+    id: `${commandSchema.action}-event-${profile.code}-vso-verb-first-2role`,
     language: profile.code,
     command: "on",
-    // This is an event handler pattern
-    priority: (config.basePriority ?? 100) + 55,
-    // Higher priority than single-role patterns
+    priority: (config.basePriority ?? 100) + 48,
     template: {
-      format: `{event} ${eventMarker.primary} ${roleNames} ${keyword.primary}`,
+      format: `${keyword.primary} ${roleNames} ${eventMarker.primary} {event}`,
       tokens
     },
     extraction: {
       action: { value: commandSchema.action },
-      // Extract the wrapped command
       event: { fromRole: "event" },
-      patient: { fromRole: "patient" },
-      destination: { fromRole: "destination" }
+      ...Object.fromEntries(sortedRoles.map((r) => [r.role, { fromRole: r.role }]))
     }
   };
 }
@@ -3300,7 +3637,7 @@ function generateVSOTwoRoleEventHandlerPattern(commandSchema, profile, keyword,
   for (const roleSpec of sortedRoles) {
     let marker;
     let markerAlternatives;
-    if (roleSpec.markerOverride && roleSpec.markerOverride[profile.code]) {
+    if (roleSpec.markerOverride && roleSpec.markerOverride[profile.code] !== void 0) {
       marker = roleSpec.markerOverride[profile.code];
     } else {
       const roleMarker = profile.roleMarkers[roleSpec.role];
@@ -3331,8 +3668,7 @@ function generateVSOTwoRoleEventHandlerPattern(commandSchema, profile, keyword,
       action: { value: commandSchema.action },
       // Extract the wrapped command
       event: { fromRole: "event" },
-      patient: { fromRole: "patient" },
-      destination: { fromRole: "destination" }
+      ...Object.fromEntries(sortedRoles.map((r) => [r.role, { fromRole: r.role }]))
     }
   };
 }
@@ -3430,6 +3766,217 @@ function generateVSOProcliticEventHandlerPattern(commandSchema, profile, keyword
     }
   };
 }
+
+// src/generators/pattern-generator.ts
+var defaultConfig = {
+  basePriority: 100,
+  generateSimpleVariants: true,
+  generateAlternatives: true
+};
+function generatePattern(schema, profile, config = defaultConfig) {
+  const id = `${schema.action}-${profile.code}-generated`;
+  const priority = config.basePriority ?? 100;
+  const keyword = profile.keywords[schema.action];
+  if (!keyword) {
+    throw new Error(`No keyword translation for '${schema.action}' in ${profile.code}`);
+  }
+  const tokens = buildTokens(schema, profile, keyword);
+  const extraction = buildExtractionRulesWithDefaults(schema, profile);
+  const format = buildFormatString(schema, profile, keyword);
+  return {
+    id,
+    language: profile.code,
+    command: schema.action,
+    priority,
+    template: {
+      format,
+      tokens
+    },
+    extraction
+  };
+}
+function generateSimplePattern(schema, profile, config = defaultConfig) {
+  const optionalRoles = schema.roles.filter((r) => !r.required);
+  if (optionalRoles.length === 0) {
+    return null;
+  }
+  const requiredRoles = schema.roles.filter((r) => r.required);
+  const simpleSchema = {
+    ...schema,
+    roles: requiredRoles
+  };
+  const pattern = generatePattern(simpleSchema, profile, config);
+  return {
+    ...pattern,
+    id: `${schema.action}-${profile.code}-simple`,
+    priority: (config.basePriority ?? 100) - 5,
+    // Lower priority than full pattern (was -10)
+    extraction: buildExtractionRulesWithDefaults(schema, profile)
+  };
+}
+function generatePatternVariants(schema, profile, config = defaultConfig) {
+  const patterns = [];
+  patterns.push(generatePattern(schema, profile, config));
+  if (config.generateSimpleVariants) {
+    const simple = generateSimplePattern(schema, profile, config);
+    if (simple) {
+      patterns.push(simple);
+    }
+  }
+  return patterns;
+}
+function generatePatternsForLanguage(profile, config = defaultConfig) {
+  const patterns = [];
+  const schemas = getDefinedSchemas();
+  for (const schema of schemas) {
+    if (!profile.keywords[schema.action]) {
+      continue;
+    }
+    const variants = generatePatternVariants(schema, profile, config);
+    patterns.push(...variants);
+    if (profile.eventHandler?.eventMarker) {
+      const eventHandlerPatterns = generateEventHandlerPatterns(schema, profile, config);
+      patterns.push(...eventHandlerPatterns);
+    }
+  }
+  return patterns;
+}
+function generateEventHandlerPatterns(commandSchema, profile, config = defaultConfig) {
+  if (!profile.eventHandler || !profile.eventHandler.eventMarker) {
+    return [];
+  }
+  const patterns = [];
+  const eventMarker = profile.eventHandler.eventMarker;
+  const keyword = profile.keywords[commandSchema.action];
+  if (!keyword) {
+    return [];
+  }
+  const requiredRoles = commandSchema.roles.filter((r) => r.required);
+  const hasTwoRequiredRoles = requiredRoles.length === 2;
+  if (profile.wordOrder === "SOV") {
+    if (hasTwoRequiredRoles) {
+      patterns.push(
+        generateSOVTwoRoleEventHandlerPattern(commandSchema, profile, keyword, eventMarker, config)
+      );
+      patterns.push(
+        generateSOVTwoRoleDestFirstEventHandlerPattern(
+          commandSchema,
+          profile,
+          keyword,
+          eventMarker,
+          config
+        )
+      );
+    } else {
+      patterns.push(
+        generateSOVEventHandlerPattern(commandSchema, profile, keyword, eventMarker, config)
+      );
+      patterns.push(
+        generateSOVPatientFirstEventHandlerPattern(
+          commandSchema,
+          profile,
+          keyword,
+          eventMarker,
+          config
+        )
+      );
+      const destMarkerCheck = profile.roleMarkers.destination;
+      if (destMarkerCheck && destMarkerCheck.primary !== eventMarker.primary) {
+        patterns.push(
+          generateSOVPatientFirstWithDestEventHandlerPattern(
+            commandSchema,
+            profile,
+            keyword,
+            eventMarker,
+            config
+          )
+        );
+      }
+      const markerWords = eventMarker.primary.split(/\s+/);
+      const hasNoSpaceAlternative = eventMarker.alternatives?.some(
+        (alt) => !alt.includes(" ") && alt.length > 1
+      );
+      if (markerWords.length > 1 && hasNoSpaceAlternative) {
+        patterns.push(
+          generateSOVCompactEventHandlerPattern(
+            commandSchema,
+            profile,
+            keyword,
+            eventMarker,
+            config
+          )
+        );
+      }
+      patterns.push(
+        generateSOVSimpleEventHandlerPattern(commandSchema, profile, keyword, eventMarker, config)
+      );
+      const temporalPattern = generateSOVTemporalEventHandlerPattern(
+        commandSchema,
+        profile,
+        keyword,
+        config
+      );
+      if (temporalPattern) {
+        patterns.push(temporalPattern);
+      }
+    }
+  } else if (profile.wordOrder === "VSO") {
+    if (hasTwoRequiredRoles) {
+      patterns.push(
+        generateVSOTwoRoleEventHandlerPattern(commandSchema, profile, keyword, eventMarker, config)
+      );
+      patterns.push(
+        generateVSOVerbFirstTwoRoleEventHandlerPattern(
+          commandSchema,
+          profile,
+          keyword,
+          eventMarker,
+          config
+        )
+      );
+    } else {
+      patterns.push(
+        generateVSOEventHandlerPattern(commandSchema, profile, keyword, eventMarker, config)
+      );
+      patterns.push(
+        generateVSOVerbFirstEventHandlerPattern(
+          commandSchema,
+          profile,
+          keyword,
+          eventMarker,
+          config
+        )
+      );
+      if (profile.eventHandler?.negationMarker) {
+        patterns.push(
+          generateVSONegatedEventHandlerPattern(
+            commandSchema,
+            profile,
+            keyword,
+            eventMarker,
+            config
+          )
+        );
+      }
+      if (profile.tokenization?.prefixes) {
+        patterns.push(
+          generateVSOProcliticEventHandlerPattern(commandSchema, profile, keyword, config)
+        );
+      }
+    }
+  } else {
+    if (hasTwoRequiredRoles) {
+      patterns.push(
+        generateVSOTwoRoleEventHandlerPattern(commandSchema, profile, keyword, eventMarker, config)
+      );
+    } else {
+      patterns.push(
+        generateVSOEventHandlerPattern(commandSchema, profile, keyword, eventMarker, config)
+      );
+    }
+  }
+  return patterns;
+}
 function buildTokens(schema, profile, keyword) {
   const tokens = [];
   const verbToken = keyword.alternatives ? { type: "literal", value: keyword.primary, alternatives: keyword.alternatives } : { type: "literal", value: keyword.primary };