@hyperfixi/core 2.7.2 → 2.9.0

package/dist/ast-utils/index.js

@@ -3756,6 +3756,9 @@ function isQuote(char) {
 function isDigit(char) {
   return /\d/.test(char);
 }
+function stripOptionalDiacritics(word) {
+  return word.replace(/[ً-ْٰ]/g, "");
+}
 function isAsciiLetter(char) {
   return /[a-zA-Z]/.test(char);
 }
@@ -4262,7 +4265,39 @@ var _BaseTokenizer = class _BaseTokenizer {
         pos++;
       }
     }
-    return new TokenStreamImpl(tokens, this.language);
+    return new TokenStreamImpl(this.mergeColonQualifiedNames(tokens), this.language);
+  }
+  /**
+   * Fuse `name` + `:qualifier` into ONE identifier (`draggable:start`).
+   *
+   * `:name` is hyperscript's local-variable sigil, but a colon IMMEDIATELY
+   * preceded by an identifier is a qualifier (custom event namespace), not a
+   * sigil. The English tokenizer already merges these inside
+   * EnglishKeywordExtractor; this post-pass gives the other 23 languages the
+   * same stream. Strict position adjacency is the discriminator: whitespace
+   * between the tokens (`trigger :start`) breaks `end === start`, so a spaced
+   * local-variable reference survives untouched.
+   *
+   * Self-gating for non-hyperscript tokenizers (domain DSLs): their extractor
+   * sets tokenize `:` as bare punctuation (length 1), which never matches
+   * COLON_QUALIFIER, so this pass is a no-op for them.
+   */
+  mergeColonQualifiedNames(tokens) {
+    const out = [];
+    for (const tok of tokens) {
+      const prev = out[out.length - 1];
+      if (prev && _BaseTokenizer.ASCII_WORD.test(prev.value) && _BaseTokenizer.COLON_QUALIFIER.test(tok.value) && prev.position.end === tok.position.start) {
+        const merged = prev.value + tok.value;
+        out[out.length - 1] = createToken(
+          merged,
+          this.classifyToken(merged),
+          createPosition(prev.position.start, tok.position.end)
+        );
+        continue;
+      }
+      out.push(tok);
+    }
+    return out;
   }
   /**
    * Classify an unknown character when no extractor matches.
@@ -4395,7 +4430,7 @@ var _BaseTokenizer = class _BaseTokenizer {
    * @returns Word without diacritics
    */
   removeDiacritics(word) {
-    return word.replace(/[\u064B-\u0652\u0670]/g, "");
+    return stripOptionalDiacritics(word);
   }
   /**
    * Try to match a keyword from profile at the current position.
@@ -4486,24 +4521,40 @@ var _BaseTokenizer = class _BaseTokenizer {
     });
   }
   /**
-   * Look up a keyword by native word (case-insensitive).
+   * Look up a keyword by native word (case-insensitive, diacritic-insensitive).
    * O(1) lookup using the keyword map.
    *
+   * The map is INDEXED both with and without diacritics (see
+   * `initializeKeywordsFromProfile`), so a stripped QUERY is the other half of
+   * that: it lets a surface form carrying harakat the profile does not happen to
+   * spell still find its entry. Only consulted after the exact lookup misses, so
+   * every previously-matching word resolves byte-identically.
+   *
+   * Half-implementing this — indexing stripped but querying exact — is what made
+   * diacritized `بَدِّل` (toggle) tokenize as `kind=particle normalized=with`:
+   * `isKeyword` returned false, so the guard in `ArabicProcliticExtractor` that
+   * exists to prevent exactly that handed the word on, and the single-char `ب`
+   * bi- proclitic claimed it. A wrong CONCEPT, not a failed parse.
+   *
    * @param native - Native word to look up
    * @returns KeywordEntry if found, undefined otherwise
    */
   lookupKeyword(native) {
-    return this.profileKeywordMap.get(native.toLowerCase());
+    const exact = this.profileKeywordMap.get(native.toLowerCase());
+    if (exact) return exact;
+    const stripped = this.removeDiacritics(native);
+    if (stripped === native) return void 0;
+    return this.profileKeywordMap.get(stripped.toLowerCase());
   }
   /**
-   * Check if a word is a known keyword (case-insensitive).
-   * O(1) lookup using the keyword map.
+   * Check if a word is a known keyword (case-insensitive, diacritic-insensitive).
+   * O(1) lookup using the keyword map. See {@link lookupKeyword}.
    *
    * @param native - Native word to check
    * @returns true if the word is a keyword
    */
   isKeyword(native) {
-    return this.profileKeywordMap.has(native.toLowerCase());
+    return this.lookupKeyword(native) !== void 0;
   }
   /**
    * Set the morphological normalizer for this tokenizer.
@@ -4768,6 +4819,14 @@ var _BaseTokenizer = class _BaseTokenizer {
     return null;
   }
 };
+/**
+ * ASCII word of the shape the English word-walker produces. Excludes `:`, so a
+ * token that already carries a qualifier never merges again — `a:b:c` yields
+ * `a:b` + `:c`, byte-matching the English extractor's single-segment merge.
+ */
+_BaseTokenizer.ASCII_WORD = /^[A-Za-z_][A-Za-z0-9_]*$/;
+/** `:name` — only a variable-ref-style extractor ever emits this token shape. */
+_BaseTokenizer.COLON_QUALIFIER = /^:[A-Za-z_][A-Za-z0-9_]*$/;
 /**
  * Configuration for native language time units.
  * Maps patterns to their standard suffix (ms, s, m, h).
@@ -4991,8 +5050,11 @@ var init_arabic = __esm({
         result: "\u0627\u0644\u0646\u062A\u064A\u062C\u0629",
         event: "\u0627\u0644\u062D\u062F\u062B",
         target: "\u0627\u0644\u0647\u062F\u0641",
-        body: "\u062C\u0633\u0645"
+        body: "\u062C\u0633\u0645",
         // matches the i18n dict's emitted body word (corpus-canonical, parser must recognize it)
+        document: "\u0648\u062B\u064A\u0642\u0629",
+        window: "\u0646\u0627\u0641\u0630\u0629",
+        detail: "\u062A\u0641\u0627\u0635\u064A\u0644"
       },
       possessive: {
         marker: "",
@@ -5101,6 +5163,30 @@ var init_arabic = __esm({
         return: { primary: "\u0627\u0631\u062C\u0639", alternatives: ["\u0639\u064F\u062F"], normalized: "return" },
         then: { primary: "\u062B\u0645", alternatives: ["\u0628\u0639\u062F\u0647\u0627", "\u062B\u0645\u0651"], normalized: "then" },
         and: { primary: "\u0648\u0623\u064A\u0636\u0627\u064B", alternatives: ["\u0623\u064A\u0636\u0627\u064B"], normalized: "and" },
+        // Comparison operator (`target matches .x`). Deferred by the Phase 2 `matches`
+        // slice because ar's operand ALSO leaked (`references.target` carried الهدف while
+        // the dict emits هدف), and registering the operator without its operand is worse
+        // than neither: modal-close-backdrop ar passed R2 only BY ACCIDENT — the unparsed
+        // condition was dropped, so `hide` ran unconditionally and coincidentally matched
+        // the en DOM effect. `matches` alone would parse the condition into a real
+        // comparison whose operand هدف evaluates to undefined, stopping `hide` and
+        // flipping R2 pass→fail at tolerance 0. Landing WITH the هدف EXTRAS entry
+        // (arabic.ts tokenizer) renders `target matches .modal-backdrop`, byte-identical
+        // to en. Not an ActionType and has no command schema, so no pattern is generated.
+        matches: { primary: "\u064A\u0637\u0627\u0628\u0642", normalized: "matches" },
+        // Existence operator (`if #modal exists`). Same seam as `matches`: without the
+        // keyword the surface stays an identifier and leaks verbatim into the
+        // condition's raw expression (if-exists). Neither an ActionType nor a command
+        // schema, so no pattern is generated from it.
+        exists: { primary: "\u0645\u0648\u062C\u0648\u062F", normalized: "exists" },
+        // Negative-existence operator (`if no dragHandle set dragHandle to me`). Same
+        // seam as `exists`: without the keyword the surface stays an identifier and
+        // leaks verbatim into the condition's raw expression (behavior-draggable).
+        // Neither an ActionType nor a command schema, so no pattern is generated from it.
+        // Uses the dict's NATURAL spaced phrase `لا يوجد`, matched by the base
+        // tokenizer's multi-word keyword walk (longest-phrase at a word boundary) —
+        // the same mechanism hi `मेل खाता` uses. Does not collide with `not: 'ليس'`.
+        no: { primary: "\u0644\u0627 \u064A\u0648\u062C\u062F", normalized: "no" },
         // آخر is deliberately ABSENT: it is the positional `last` keyword
         // (آخر <button/> في .modal — see pattern-matcher's positional handling).
         // Listing it as an end-alternative made parseBodyWithClauses chop every
@@ -5116,9 +5202,12 @@ var init_arabic = __esm({
         behavior: { primary: "\u0633\u0644\u0648\u0643", normalized: "behavior" },
         install: { primary: "\u062A\u062B\u0628\u064A\u062A", alternatives: ["\u062B\u0628\u0651\u062A"], normalized: "install" },
         // `قِس` is the imperative with the kasra diacritic; the i18n dict (and real
-        // Arabic prose) emits it undiacritized as `قس`, so list both — otherwise the
-        // generated `قس width`/`قس x` (behavior-draggable/resizable) parse to null and
-        // the whole `measure` command drops from the event-handler body (lossy).
+        // Arabic prose) emits it undiacritized as `قس`. BOTH stay listed, and not
+        // for the tokenizer's sake — keyword lookup is diacritic-insensitive now, so
+        // either spelling resolves. It is the vocab gate's V1 check, which compares
+        // the profile against the i18n DICTIONARY as strings: the dictionary says
+        // `قس`, so dropping it here fails V1 (verified). Diacritic-insensitivity
+        // would have to reach that comparison too before this pair can collapse.
         measure: { primary: "\u0642\u064A\u0627\u0633", alternatives: ["\u0642\u0650\u0633", "\u0642\u0633"], normalized: "measure" },
         beep: { primary: "\u0635\u0641\u0651\u0631", normalized: "beep" },
         break: { primary: "\u062A\u0648\u0642\u0641", normalized: "break" },
@@ -5304,6 +5393,11 @@ var init_bengali = __esm({
         return: { primary: "\u09AB\u09BF\u09B0\u09C1\u09A8", alternatives: ["\u09AB\u09C7\u09B0\u09A4 \u09A6\u09BF\u09A8"], normalized: "return" },
         then: { primary: "\u09A4\u09BE\u09B0\u09AA\u09B0", alternatives: ["\u09A4\u0996\u09A8"], normalized: "then" },
         and: { primary: "\u098F\u09AC\u0982", alternatives: [], normalized: "and" },
+        // Copula (`if result is false`, `if my value is empty`). Without the keyword the
+        // surface stays an identifier and leaks verbatim into the condition's raw
+        // expression, which the core expression parser reads as English. Neither an
+        // ActionType nor a command schema, so no pattern is generated from it.
+        is: { primary: "\u09B9\u09AF\u09BC", normalized: "is" },
         end: { primary: "\u09B6\u09C7\u09B7", alternatives: ["\u09B8\u09AE\u09BE\u09AA\u09CD\u09A4"], normalized: "end" },
         // Advanced
         js: { primary: "\u099C\u09C7\u098F\u09B8", alternatives: ["js"], normalized: "js" },
@@ -5401,7 +5495,10 @@ var init_german = __esm({
         result: "Ergebnis",
         event: "Ereignis",
         target: "Ziel",
-        body: "K\xF6rper"
+        body: "K\xF6rper",
+        document: "dokument",
+        window: "fenster",
+        detail: "detail"
       },
       possessive: {
         marker: "",
@@ -5496,6 +5593,22 @@ var init_german = __esm({
         // Predicate keywords (conditionals) — mirrors the Spanish profile, the only
         // language that previously parsed `is empty`-style predicates.
         is: { primary: "ist", normalized: "is" },
+        // Comparison operator (`target matches .x`). Without this keyword the surface
+        // stays an identifier and leaks verbatim into the condition's raw expression,
+        // which the core expression parser reads as English (modal-close-backdrop /
+        // focus-trap drop their then-branch). Not an ActionType and has no command
+        // schema, so no pattern is generated from it.
+        matches: { primary: "passt", normalized: "matches" },
+        // Existence operator (`if #modal exists`). Same seam as `matches`: without the
+        // keyword the surface stays an identifier and leaks verbatim into the
+        // condition's raw expression (if-exists). Neither an ActionType nor a command
+        // schema, so no pattern is generated from it.
+        exists: { primary: "existiert", normalized: "exists" },
+        // Negative-existence operator (`if no dragHandle set dragHandle to me`). Same
+        // seam as `exists`: without the keyword the surface stays an identifier and
+        // leaks verbatim into the condition's raw expression (behavior-draggable).
+        // Neither an ActionType nor a command schema, so no pattern is generated from it.
+        no: { primary: "kein", normalized: "no" },
         end: { primary: "ende", alternatives: ["fertig"], normalized: "end" },
         js: { primary: "js", alternatives: ["javascript"], normalized: "js" },
         async: { primary: "asynchron", normalized: "async" },
@@ -5590,7 +5703,10 @@ var init_english = __esm({
         result: "result",
         event: "event",
         target: "target",
-        body: "body"
+        body: "body",
+        document: "document",
+        window: "window",
+        detail: "detail"
       },
       possessive: {
         marker: "'s",
@@ -5741,7 +5857,10 @@ var init_spanish = __esm({
         event: "evento",
         target: "objetivo",
         // destino is a synonym
-        body: "cuerpo"
+        body: "cuerpo",
+        document: "documento",
+        window: "ventana",
+        detail: "detalle"
       },
       possessive: {
         marker: "de",
@@ -5764,11 +5883,23 @@ var init_spanish = __esm({
         }
       },
       roleMarkers: {
-        destination: { primary: "en", alternatives: ["sobre", "a"], position: "before" },
+        // `hacia` is the i18n grammar's optional destination render form ("towards");
+        // without it here a rendered/user `hacia` clause silently dropped the
+        // destination (add → default `me`, put → null parse). Vocab Batch 1 (V2+V4).
+        destination: { primary: "en", alternatives: ["sobre", "a", "hacia"], position: "before" },
         source: { primary: "de", alternatives: ["desde"], position: "before" },
         patient: { primary: "", position: "before" },
         style: { primary: "con", position: "before" }
       },
+      // Imperative command forms are accepted on INPUT only — `primary` stays the
+      // dictionary form, so rendering is unchanged (see LanguageProfile.defaultVerbForm:
+      // infinitive is the industry standard for UI localization). Hyperscript is a
+      // command language, though, and a native speaker giving a command writes the
+      // imperative, so the parser should read it.
+      //
+      // Only the IRREGULARS are listed. The regular ones reach their keyword through
+      // the morphological normalizer's stem (see spanish-keyword.ts and siblings),
+      // which also covers conjugations nobody enumerated here.
       keywords: {
         // Class/Attribute operations
         toggle: { primary: "alternar", alternatives: ["conmutar", "toggle"], normalized: "toggle" },
@@ -5788,19 +5919,23 @@ var init_spanish = __esm({
         swap: { primary: "intercambiar", alternatives: ["permutar"], normalized: "swap" },
         morph: { primary: "transformar", alternatives: ["convertir"], normalized: "morph" },
         // Variable operations
-        set: { primary: "establecer", alternatives: ["fijar", "definir"], normalized: "set" },
-        get: { primary: "obtener", alternatives: ["conseguir"], normalized: "get" },
+        set: {
+          primary: "establecer",
+          alternatives: ["fijar", "definir", "establece"],
+          normalized: "set"
+        },
+        get: { primary: "obtener", alternatives: ["conseguir", "obt\xE9n"], normalized: "get" },
         increment: { primary: "incrementar", alternatives: ["aumentar"], normalized: "increment" },
         decrement: { primary: "decrementar", alternatives: ["disminuir"], normalized: "decrement" },
         log: { primary: "registrar", alternatives: ["imprimir"], normalized: "log" },
         // Visibility
-        show: { primary: "mostrar", alternatives: ["ense\xF1ar"], normalized: "show" },
+        show: { primary: "mostrar", alternatives: ["ense\xF1ar", "muestra"], normalized: "show" },
         hide: { primary: "ocultar", alternatives: ["esconder"], normalized: "hide" },
         transition: { primary: "transici\xF3n", alternatives: ["animar"], normalized: "transition" },
         // Events
         on: { primary: "en", alternatives: ["al"], normalized: "on" },
         trigger: { primary: "disparar", alternatives: ["activar"], normalized: "trigger" },
-        send: { primary: "enviar", normalized: "send" },
+        send: { primary: "enviar", alternatives: ["env\xEDa"], normalized: "send" },
         // DOM focus
         focus: { primary: "enfocar", alternatives: ["enfoque"], normalized: "focus" },
         blur: { primary: "desenfocar", alternatives: ["desenfoque"], normalized: "blur" },
@@ -5837,7 +5972,7 @@ var init_spanish = __esm({
         mousedown: { primary: "rat\xF3nabajo", normalized: "mousedown" },
         mouseup: { primary: "rat\xF3narriba", normalized: "mouseup" },
         // Navigation
-        go: { primary: "ir", alternatives: ["navegar"], normalized: "go" },
+        go: { primary: "ir", alternatives: ["navegar", "ve"], normalized: "go" },
         push: { primary: "empujar", alternatives: ["push"], normalized: "push" },
         replace: { primary: "reemplazar", alternatives: ["sustituir"], normalized: "replace" },
         process: { primary: "procesar", normalized: "process" },
@@ -5874,6 +6009,19 @@ var init_spanish = __esm({
         is: { primary: "es", normalized: "is" },
         exists: { primary: "existe", normalized: "exists" },
         empty: { primary: "vac\xEDo", alternatives: ["vacio"], normalized: "empty" },
+        // Comparison operator (`target matches .x`). Without this keyword the surface
+        // stays an identifier and leaks verbatim into the condition's raw expression,
+        // which the core expression parser reads as English (modal-close-backdrop /
+        // focus-trap drop their then-branch). Not an ActionType and has no command
+        // schema, so no pattern is generated from it.
+        matches: { primary: "coincide", normalized: "matches" },
+        // Negative-existence operator (`if no dragHandle set dragHandle to me`). Same
+        // seam as `exists`: without the keyword the surface stays an identifier and
+        // leaks verbatim into the condition's raw expression (behavior-draggable).
+        // Neither an ActionType nor a command schema, so no pattern is generated from it.
+        // Does NOT collide with `not: { primary: 'no' }`: the keyword map is keyed by
+        // SURFACE, so this registers `ningún` and leaves the `no` surface untouched.
+        no: { primary: "ning\xFAn", normalized: "no" },
         end: { primary: "fin", alternatives: ["final", "terminar"], normalized: "end" },
         // Advanced
         js: { primary: "js", normalized: "js" },
@@ -5977,7 +6125,10 @@ var init_french = __esm({
         result: "r\xE9sultat",
         event: "\xE9v\xE9nement",
         target: "cible",
-        body: "corps"
+        body: "corps",
+        document: "document",
+        window: "fen\xEAtre",
+        detail: "d\xE9tail"
       },
       possessive: {
         marker: "de",
@@ -6010,11 +6161,24 @@ var init_french = __esm({
         patient: { primary: "", position: "before" },
         style: { primary: "avec", position: "before" }
       },
+      // Imperative command forms are accepted on INPUT only — `primary` stays the
+      // dictionary form, so rendering is unchanged (see LanguageProfile.defaultVerbForm:
+      // infinitive is the industry standard for UI localization). Hyperscript is a
+      // command language, though, and a native speaker giving a command writes the
+      // imperative, so the parser should read it.
+      //
+      // Only the IRREGULARS are listed. The regular ones reach their keyword through
+      // the morphological normalizer's stem (see spanish-keyword.ts and siblings),
+      // which also covers conjugations nobody enumerated here.
       keywords: {
         toggle: { primary: "basculer", alternatives: ["alterner"], normalized: "toggle" },
         add: { primary: "ajouter", normalized: "add" },
-        remove: { primary: "supprimer", alternatives: ["enlever", "retirer"], normalized: "remove" },
-        put: { primary: "mettre", alternatives: ["placer"], normalized: "put" },
+        remove: {
+          primary: "supprimer",
+          alternatives: ["enlever", "retirer", "retire"],
+          normalized: "remove"
+        },
+        put: { primary: "mettre", alternatives: ["placer", "mets"], normalized: "put" },
         append: { primary: "annexer", normalized: "append" },
         prepend: { primary: "pr\xE9fixer", normalized: "prepend" },
         take: { primary: "prendre", normalized: "take" },
@@ -6023,16 +6187,16 @@ var init_french = __esm({
         swap: { primary: "\xE9changer", alternatives: ["permuter"], normalized: "swap" },
         morph: { primary: "transformer", alternatives: ["m\xE9tamorphoser"], normalized: "morph" },
         set: { primary: "d\xE9finir", alternatives: ["\xE9tablir"], normalized: "set" },
-        get: { primary: "obtenir", normalized: "get" },
+        get: { primary: "obtenir", alternatives: ["obtiens"], normalized: "get" },
         increment: { primary: "incr\xE9menter", alternatives: ["augmenter"], normalized: "increment" },
         decrement: { primary: "d\xE9cr\xE9menter", alternatives: ["diminuer"], normalized: "decrement" },
         log: { primary: "enregistrer", alternatives: ["journaliser"], normalized: "log" },
-        show: { primary: "montrer", alternatives: ["afficher"], normalized: "show" },
+        show: { primary: "montrer", alternatives: ["afficher", "montre"], normalized: "show" },
         hide: { primary: "cacher", alternatives: ["masquer"], normalized: "hide" },
         transition: { primary: "transition", alternatives: ["animer"], normalized: "transition" },
         on: { primary: "sur", alternatives: ["lors"], normalized: "on" },
         trigger: { primary: "d\xE9clencher", normalized: "trigger" },
-        send: { primary: "envoyer", normalized: "send" },
+        send: { primary: "envoyer", alternatives: ["envoie"], normalized: "send" },
         focus: { primary: "focaliser", alternatives: ["concentrer"], normalized: "focus" },
         blur: { primary: "d\xE9focaliser", normalized: "blur" },
         // Phase 1 (v0.9.90): DOM / form state / debug
@@ -6046,13 +6210,13 @@ var init_french = __esm({
         clear: { primary: "effacer", normalized: "clear" },
         reset: { primary: "r\xE9initialiser", alternatives: ["reinitialiser"], normalized: "reset" },
         breakpoint: { primary: "point-arr\xEAt", alternatives: ["point-arret"], normalized: "breakpoint" },
-        go: { primary: "aller", alternatives: ["naviguer"], normalized: "go" },
+        go: { primary: "aller", alternatives: ["naviguer", "va"], normalized: "go" },
         scroll: { primary: "d\xE9filer", alternatives: ["faire-d\xE9filer"], normalized: "scroll" },
         push: { primary: "pousser", normalized: "push" },
         replace: { primary: "remplacer", normalized: "replace" },
         process: { primary: "traiter", normalized: "process" },
         wait: { primary: "attendre", normalized: "wait" },
-        fetch: { primary: "chercher", alternatives: ["r\xE9cup\xE9rer"], normalized: "fetch" },
+        fetch: { primary: "chercher", alternatives: ["r\xE9cup\xE9rer", "r\xE9cup\xE8re"], normalized: "fetch" },
         settle: { primary: "stabiliser", normalized: "settle" },
         if: { primary: "si", normalized: "if" },
         unless: { primary: "saufsi", normalized: "unless" },
@@ -6072,6 +6236,27 @@ var init_french = __esm({
         return: { primary: "retourner", alternatives: ["renvoyer"], normalized: "return" },
         then: { primary: "puis", alternatives: ["ensuite", "alors"], normalized: "then" },
         and: { primary: "et", alternatives: ["aussi", "\xE9galement"], normalized: "and" },
+        // Comparison operator (`target matches .x`). Without this keyword the surface
+        // stays an identifier and leaks verbatim into the condition's raw expression,
+        // which the core expression parser reads as English (modal-close-backdrop /
+        // focus-trap drop their then-branch). Not an ActionType and has no command
+        // schema, so no pattern is generated from it.
+        matches: { primary: "correspond", normalized: "matches" },
+        // Existence operator (`if #modal exists`). Same seam as `matches`: without the
+        // keyword the surface stays an identifier and leaks verbatim into the
+        // condition's raw expression (if-exists). Neither an ActionType nor a command
+        // schema, so no pattern is generated from it.
+        exists: { primary: "existe", normalized: "exists" },
+        // Copula (`if result is false`, `if my value is empty`). Without the keyword the
+        // surface stays an identifier and leaks verbatim into the condition's raw
+        // expression, which the core expression parser reads as English. Neither an
+        // ActionType nor a command schema, so no pattern is generated from it.
+        is: { primary: "est", normalized: "is" },
+        // Negative-existence operator (`if no dragHandle set dragHandle to me`). Same
+        // seam as `exists`: without the keyword the surface stays an identifier and
+        // leaks verbatim into the condition's raw expression (behavior-draggable).
+        // Neither an ActionType nor a command schema, so no pattern is generated from it.
+        no: { primary: "aucun", normalized: "no" },
         end: { primary: "fin", alternatives: ["terminer", "finir"], normalized: "end" },
         js: { primary: "js", normalized: "js" },
         async: { primary: "asynchrone", normalized: "async" },
@@ -6377,7 +6562,10 @@ var init_hindi = __esm({
         result: "\u092A\u0930\u093F\u0923\u093E\u092E",
         event: "\u0918\u091F\u0928\u093E",
         target: "\u0932\u0915\u094D\u0937\u094D\u092F",
-        body: "\u092C\u0949\u0921\u0940"
+        body: "\u092C\u0949\u0921\u0940",
+        document: "\u0926\u0938\u094D\u0924\u093E\u0935\u0947\u091C\u093C",
+        window: "\u0935\u093F\u0902\u0921\u094B",
+        detail: "\u0935\u093F\u0935\u0930\u0923"
       },
       possessive: {
         marker: "\u0915\u093E",
@@ -6527,6 +6715,11 @@ var init_hindi = __esm({
         // parser. (History: `मेल_खाता` underscore-split to मेल/_/खाता; the concatenated
         // `मेलखाता` parsed but isn't how Hindi is written.)
         matches: { primary: "\u092E\u0947\u0932 \u0916\u093E\u0924\u093E", normalized: "matches" },
+        // Existence operator (`if #modal exists`). Same seam as `matches`: without the
+        // keyword the surface stays an identifier and leaks verbatim into the
+        // condition's raw expression (if-exists). Neither an ActionType nor a command
+        // schema, so no pattern is generated from it.
+        exists: { primary: "\u092E\u094C\u091C\u0942\u0926", normalized: "exists" },
         end: { primary: "\u0938\u092E\u093E\u092A\u094D\u0924", alternatives: ["\u0905\u0902\u0924"], normalized: "end" },
         // Advanced
         js: { primary: "\u091C\u0947\u090F\u0938", alternatives: ["js"], normalized: "js" },
@@ -6626,8 +6819,11 @@ var init_indonesian = __esm({
         result: "hasil",
         event: "peristiwa",
         target: "target",
-        body: "badan"
+        body: "badan",
         // matches the i18n dict's emitted body word (corpus-canonical; tubuh = anatomical body)
+        document: "dokumen",
+        window: "jendela",
+        detail: "detail"
       },
       possessive: {
         marker: "",
@@ -6748,6 +6944,12 @@ var init_indonesian = __esm({
         return: { primary: "kembalikan", alternatives: ["kembali"], normalized: "return" },
         then: { primary: "lalu", alternatives: ["kemudian", "setelah itu"], normalized: "then" },
         and: { primary: "dan", alternatives: ["juga", "serta"], normalized: "and" },
+        // Comparison operator (`target matches .x`). Without this keyword the surface
+        // stays an identifier and leaks verbatim into the condition's raw expression,
+        // which the core expression parser reads as English (modal-close-backdrop /
+        // focus-trap drop their then-branch). Not an ActionType and has no command
+        // schema, so no pattern is generated from it.
+        matches: { primary: "cocok", normalized: "matches" },
         end: { primary: "selesai", alternatives: ["akhir", "tamat"], normalized: "end" },
         js: { primary: "js", alternatives: ["javascript"], normalized: "js" },
         async: { primary: "asinkron", normalized: "async" },
@@ -6854,7 +7056,10 @@ var init_italian = __esm({
         result: "risultato",
         event: "evento",
         target: "obiettivo",
-        body: "corpo"
+        body: "corpo",
+        document: "documento",
+        window: "finestra",
+        detail: "dettaglio"
       },
       possessive: {
         marker: "di",
@@ -6961,6 +7166,17 @@ var init_italian = __esm({
         return: { primary: "ritornare", normalized: "return" },
         then: { primary: "allora", alternatives: ["poi", "quindi"], normalized: "then" },
         and: { primary: "e", alternatives: ["anche"], normalized: "and" },
+        // Comparison operator (`target matches .x`). Without this keyword the surface
+        // stays an identifier and leaks verbatim into the condition's raw expression,
+        // which the core expression parser reads as English (modal-close-backdrop /
+        // focus-trap drop their then-branch). Not an ActionType and has no command
+        // schema, so no pattern is generated from it.
+        matches: { primary: "corrisponde", normalized: "matches" },
+        // Negative-existence operator (`if no dragHandle set dragHandle to me`). Same
+        // seam as `exists`: without the keyword the surface stays an identifier and
+        // leaks verbatim into the condition's raw expression (behavior-draggable).
+        // Neither an ActionType nor a command schema, so no pattern is generated from it.
+        no: { primary: "nessun", normalized: "no" },
         end: { primary: "fine", normalized: "end" },
         // Advanced
         js: { primary: "js", normalized: "js" },
@@ -7074,7 +7290,10 @@ var init_japanese = __esm({
         result: "\u7D50\u679C",
         event: "\u30A4\u30D9\u30F3\u30C8",
         target: "\u30BF\u30FC\u30B2\u30C3\u30C8",
-        body: "\u30DC\u30C7\u30A3"
+        body: "\u30DC\u30C7\u30A3",
+        document: "\u30C9\u30AD\u30E5\u30E1\u30F3\u30C8",
+        window: "\u30A6\u30A3\u30F3\u30C9\u30A6",
+        detail: "\u8A73\u7D30"
       },
       possessive: {
         marker: "\u306E",
@@ -7152,6 +7371,10 @@ var init_japanese = __esm({
         focus: { primary: "\u30D5\u30A9\u30FC\u30AB\u30B9", alternatives: ["\u96C6\u4E2D"], normalized: "focus" },
         blur: { primary: "\u307C\u304B\u3057", alternatives: ["\u30D5\u30A9\u30FC\u30AB\u30B9\u89E3\u9664", "\u30D6\u30E9\u30FC"], normalized: "blur" },
         // Phase 1 (v0.9.90): DOM / form state / debug
+        // Batch 3: do NOT add bare 空 here — probed: registering it as an empty
+        // keyword injects a phantom `empty` command into the corpus-hot `is empty`
+        // expression rows (である 空), an R0-precision regression. The empty-COMMAND
+        // render gap (dict renders 空, parses null) is waived instead.
         empty: { primary: "\u7A7A\u306B", alternatives: ["\u7A7A\u306B\u3059\u308B"], normalized: "empty" },
         open: { primary: "\u958B\u304F", alternatives: ["\u30AA\u30FC\u30D7\u30F3"], normalized: "open" },
         close: { primary: "\u9589\u3058\u308B", alternatives: ["\u30AF\u30ED\u30FC\u30BA"], normalized: "close" },
@@ -7195,6 +7418,32 @@ var init_japanese = __esm({
         return: { primary: "\u623B\u308B", alternatives: ["\u8FD4\u3059", "\u30EA\u30BF\u30FC\u30F3"], normalized: "return" },
         then: { primary: "\u305D\u308C\u304B\u3089", alternatives: ["\u6B21\u306B", "\u306A\u3089\u3070", "\u306A\u3089"], normalized: "then" },
         and: { primary: "\u307E\u305F", alternatives: ["\u3068", "\u305D\u3057\u3066"], normalized: "and" },
+        // Comparison operator (`target matches .x`). Deferred by the Phase 2 `matches`
+        // slice because ja's operand ALSO leaked (`references.target` carried ターゲット
+        // while the dict emits 対象), and registering the operator without its operand is
+        // worse than neither: modal-close-backdrop ja passed R2 only BY ACCIDENT — the
+        // unparsed condition was dropped, so `hide` ran unconditionally and coincidentally
+        // matched the en DOM effect. `matches` alone would parse the condition into a real
+        // comparison whose operand 対象 evaluates to undefined, stopping `hide` and
+        // flipping R2 pass→fail at tolerance 0. Landing WITH the 対象 EXTRAS entry
+        // (japanese.ts tokenizer) renders `target matches .modal-backdrop`, byte-identical
+        // to en. Not an ActionType and has no command schema, so no pattern is generated.
+        matches: { primary: "\u4E00\u81F4\u3059\u308B", normalized: "matches" },
+        // Existence operator (`if #modal exists`). Same seam as `matches`: without the
+        // keyword the surface stays an identifier and leaks verbatim into the
+        // condition's raw expression (if-exists). Neither an ActionType nor a command
+        // schema, so no pattern is generated from it.
+        exists: { primary: "\u5B58\u5728\u3059\u308B", normalized: "exists" },
+        // Copula (`if result is false`, `if my value is empty`). Without the keyword the
+        // surface stays an identifier and leaks verbatim into the condition's raw
+        // expression, which the core expression parser reads as English. Neither an
+        // ActionType nor a command schema, so no pattern is generated from it.
+        is: { primary: "\u3067\u3042\u308B", normalized: "is" },
+        // Negative-existence operator (`if no dragHandle set dragHandle to me`). Same
+        // seam as `exists`: without the keyword the surface stays an identifier and
+        // leaks verbatim into the condition's raw expression (behavior-draggable).
+        // Neither an ActionType nor a command schema, so no pattern is generated from it.
+        no: { primary: "\u306A\u3044", normalized: "no" },
         // 終了 removed: it is the i18n dict's `exit` emission (ja.ts), so listing it
         // as an `end` alternative made an `exit` inside `if … exit … end` read as the
         // block terminator and collapse the handler body (behavior-sortable). 終わり is
@@ -7297,8 +7546,11 @@ var init_korean = __esm({
         result: "\uACB0\uACFC",
         event: "\uC774\uBCA4\uD2B8",
         target: "\uB300\uC0C1",
-        body: "\uBC14\uB514"
+        body: "\uBC14\uB514",
         // matches the i18n dict's emitted body word (본문 = "main text", wrong for the DOM body element)
+        document: "\uBB38\uC11C",
+        window: "\uCC3D",
+        detail: "\uC138\uBD80"
       },
       possessive: {
         marker: "\uC758",
@@ -7335,16 +7587,25 @@ var init_korean = __esm({
         event: { primary: "\uC744", alternatives: ["\uB97C"], position: "after" }
         // Event as object marker
       },
+      // Imperative command forms are accepted on INPUT only — `primary` stays the
+      // dictionary form, so rendering is unchanged (see LanguageProfile.defaultVerbForm:
+      // infinitive is the industry standard for UI localization). Hyperscript is a
+      // command language, though, and a native speaker giving a command writes the
+      // imperative, so the parser should read it.
+      //
+      // Only the IRREGULARS are listed. The regular ones reach their keyword through
+      // the morphological normalizer's stem (see spanish-keyword.ts and siblings),
+      // which also covers conjugations nobody enumerated here.
       keywords: {
         // Class/Attribute operations
         toggle: { primary: "\uD1A0\uAE00", normalized: "toggle" },
         add: { primary: "\uCD94\uAC00", normalized: "add" },
         remove: { primary: "\uC81C\uAC70", alternatives: ["\uC0AD\uC81C"], normalized: "remove" },
         // Content operations
-        put: { primary: "\uB123\uB2E4", alternatives: ["\uB123\uAE30", "\uB193\uAE30"], normalized: "put" },
+        put: { primary: "\uB123\uB2E4", alternatives: ["\uB123\uAE30", "\uB193\uAE30", "\uB123\uC73C\uC138\uC694"], normalized: "put" },
         append: { primary: "\uB367\uBD99\uC774\uB2E4", alternatives: ["\uB05D\uC5D0\uCD94\uAC00"], normalized: "append" },
         prepend: { primary: "\uC55E\uC5D0\uCD94\uAC00", alternatives: ["\uC120\uB450\uCD94\uAC00"], normalized: "prepend" },
-        take: { primary: "\uAC00\uC838\uC624\uB2E4", normalized: "take" },
+        take: { primary: "\uAC00\uC838\uC624\uB2E4", alternatives: ["\uAC00\uC838\uC624\uC138\uC694"], normalized: "take" },
         make: { primary: "\uB9CC\uB4E4\uB2E4", normalized: "make" },
         clone: { primary: "\uBCF5\uC81C", normalized: "clone" },
         // 복제=duplicate/clone, 복사=copy
@@ -7352,13 +7613,13 @@ var init_korean = __esm({
         morph: { primary: "\uBCC0\uD615", alternatives: ["\uBCC0\uD658"], normalized: "morph" },
         // Variable operations
         set: { primary: "\uC124\uC815", normalized: "set" },
-        get: { primary: "\uC5BB\uB2E4", normalized: "get" },
+        get: { primary: "\uC5BB\uB2E4", alternatives: ["\uC5BB\uC73C\uC138\uC694"], normalized: "get" },
         increment: { primary: "\uC99D\uAC00", normalized: "increment" },
         decrement: { primary: "\uAC10\uC18C", normalized: "decrement" },
         log: { primary: "\uB85C\uADF8", normalized: "log" },
         // Visibility
-        show: { primary: "\uBCF4\uC774\uB2E4", alternatives: ["\uD45C\uC2DC", "\uBCF4\uC774\uAE30"], normalized: "show" },
-        hide: { primary: "\uC228\uAE30\uB2E4", alternatives: ["\uC228\uAE30\uAE30"], normalized: "hide" },
+        show: { primary: "\uBCF4\uC774\uB2E4", alternatives: ["\uD45C\uC2DC", "\uBCF4\uC774\uAE30", "\uBCF4\uC774\uC138\uC694"], normalized: "show" },
+        hide: { primary: "\uC228\uAE30\uB2E4", alternatives: ["\uC228\uAE30\uAE30", "\uC228\uAE30\uC138\uC694"], normalized: "hide" },
         // primary is the loanword 트랜지션; 전환 ("switch/transition") is the form the
         // i18n transformer emits — registered as an alternative (passthrough-alignment).
         // toggle uses 토글, so 전환 carries no collision.
@@ -7366,12 +7627,14 @@ var init_korean = __esm({
         // Events
         on: { primary: "\uC5D0", alternatives: ["\uC2DC", "\uD560 \uB54C"], normalized: "on" },
         trigger: { primary: "\uD2B8\uB9AC\uAC70", normalized: "trigger" },
-        send: { primary: "\uBCF4\uB0B4\uB2E4", normalized: "send" },
+        send: { primary: "\uBCF4\uB0B4\uB2E4", alternatives: ["\uBCF4\uB0B4\uC138\uC694"], normalized: "send" },
         // DOM focus
         focus: { primary: "\uD3EC\uCEE4\uC2A4", normalized: "focus" },
         blur: { primary: "\uBE14\uB7EC", normalized: "blur" },
         // Phase 1 (v0.9.90): DOM / form state / debug
-        empty: { primary: "\uBE44\uC6B0\uAE30", normalized: "empty" },
+        // Batch 3: 비어있는 added — the i18n dict renders the empty COMMAND with its
+        // `is empty` adjective (category-shadowed), which parsed null.
+        empty: { primary: "\uBE44\uC6B0\uAE30", alternatives: ["\uBE44\uC5B4\uC788\uB294"], normalized: "empty" },
         open: { primary: "\uC5F4\uAE30", normalized: "open" },
         close: { primary: "\uB2EB\uAE30", normalized: "close" },
         select: { primary: "\uACE0\uB974\uAE30", normalized: "select" },
@@ -7428,6 +7691,16 @@ var init_korean = __esm({
         // matches .x`. Without this keyword `일치` stays an identifier and the
         // condition is unevaluable (modal-close-backdrop drops its then-branch).
         matches: { primary: "\uC77C\uCE58", normalized: "matches" },
+        // Existence operator (`if #modal exists`). Same seam as `matches`: without the
+        // keyword the surface stays an identifier and leaks verbatim into the
+        // condition's raw expression (if-exists). Neither an ActionType nor a command
+        // schema, so no pattern is generated from it.
+        exists: { primary: "\uC874\uC7AC", normalized: "exists" },
+        // Negative-existence operator (`if no dragHandle set dragHandle to me`). Same
+        // seam as `exists`: without the keyword the surface stays an identifier and
+        // leaks verbatim into the condition's raw expression (behavior-draggable).
+        // Neither an ActionType nor a command schema, so no pattern is generated from it.
+        no: { primary: "\uC5C6\uC74C", normalized: "no" },
         end: { primary: "\uB05D", alternatives: ["\uB9C8\uCE68"], normalized: "end" },
         // Advanced
         js: { primary: "JS\uC2E4\uD589", alternatives: ["js"], normalized: "js" },
@@ -7519,7 +7792,10 @@ var init_ms = __esm({
         result: "hasil",
         event: "peristiwa",
         target: "sasaran",
-        body: "badan"
+        body: "badan",
+        document: "dokumen",
+        window: "tetingkap",
+        detail: "perincian"
       },
       possessive: {
         marker: "",
@@ -7642,6 +7918,27 @@ var init_ms = __esm({
         return: { primary: "pulang", alternatives: ["kembali"], normalized: "return" },
         then: { primary: "kemudian", alternatives: ["lepas_itu"], normalized: "then" },
         and: { primary: "dan", normalized: "and" },
+        // Comparison operator (`target matches .x`). Without this keyword the surface
+        // stays an identifier and leaks verbatim into the condition's raw expression,
+        // which the core expression parser reads as English (modal-close-backdrop /
+        // focus-trap drop their then-branch). Not an ActionType and has no command
+        // schema, so no pattern is generated from it.
+        matches: { primary: "sepadan", normalized: "matches" },
+        // Existence operator (`if #modal exists`). Same seam as `matches`: without the
+        // keyword the surface stays an identifier and leaks verbatim into the
+        // condition's raw expression (if-exists). Neither an ActionType nor a command
+        // schema, so no pattern is generated from it.
+        exists: { primary: "wujud", normalized: "exists" },
+        // Copula (`if result is false`, `if my value is empty`). Without the keyword the
+        // surface stays an identifier and leaks verbatim into the condition's raw
+        // expression, which the core expression parser reads as English. Neither an
+        // ActionType nor a command schema, so no pattern is generated from it.
+        is: { primary: "adalah", normalized: "is" },
+        // Negative-existence operator (`if no dragHandle set dragHandle to me`). Same
+        // seam as `exists`: without the keyword the surface stays an identifier and
+        // leaks verbatim into the condition's raw expression (behavior-draggable).
+        // Neither an ActionType nor a command schema, so no pattern is generated from it.
+        no: { primary: "tiada", normalized: "no" },
         end: { primary: "tamat", alternatives: ["habis"], normalized: "end" },
         // Advanced
         js: { primary: "js", normalized: "js" },
@@ -7728,7 +8025,10 @@ var init_polish = __esm({
         result: "wynik",
         event: "zdarzenie",
         target: "cel",
-        body: "body"
+        body: "body",
+        document: "dokument",
+        window: "okno",
+        detail: "szczeg\xF3\u0142"
       },
       possessive: {
         marker: "",
@@ -7961,6 +8261,17 @@ var init_polish = __esm({
           normalized: "then"
         },
         and: { primary: "i", alternatives: ["oraz"], normalized: "and" },
+        // Comparison operator (`target matches .x`). Without this keyword the surface
+        // stays an identifier and leaks verbatim into the condition's raw expression,
+        // which the core expression parser reads as English (modal-close-backdrop /
+        // focus-trap drop their then-branch). Not an ActionType and has no command
+        // schema, so no pattern is generated from it.
+        matches: { primary: "pasuje", normalized: "matches" },
+        // Negative-existence operator (`if no dragHandle set dragHandle to me`). Same
+        // seam as `exists`: without the keyword the surface stays an identifier and
+        // leaks verbatim into the condition's raw expression (behavior-draggable).
+        // Neither an ActionType nor a command schema, so no pattern is generated from it.
+        no: { primary: "brak", normalized: "no" },
         end: { primary: "koniec", normalized: "end" },
         // Advanced
         js: { primary: "js", normalized: "js" },
@@ -8065,7 +8376,10 @@ var init_portuguese = __esm({
         result: "resultado",
         event: "evento",
         target: "alvo",
-        body: "corpo"
+        body: "corpo",
+        document: "documento",
+        window: "janela",
+        detail: "detalhe"
       },
       possessive: {
         marker: "de",
@@ -8095,25 +8409,38 @@ var init_portuguese = __esm({
         patient: { primary: "", position: "before" },
         style: { primary: "com", position: "before" }
       },
+      // Imperative command forms are accepted on INPUT only — `primary` stays the
+      // dictionary form, so rendering is unchanged (see LanguageProfile.defaultVerbForm:
+      // infinitive is the industry standard for UI localization). Hyperscript is a
+      // command language, though, and a native speaker giving a command writes the
+      // imperative, so the parser should read it.
+      //
+      // Only the IRREGULARS are listed. The regular ones reach their keyword through
+      // the morphological normalizer's stem (see spanish-keyword.ts and siblings),
+      // which also covers conjugations nobody enumerated here.
       keywords: {
         toggle: { primary: "alternar", alternatives: [], normalized: "toggle" },
         add: { primary: "adicionar", alternatives: ["acrescentar"], normalized: "add" },
-        remove: { primary: "remover", alternatives: ["eliminar", "apagar"], normalized: "remove" },
-        put: { primary: "colocar", alternatives: ["p\xF4r", "por"], normalized: "put" },
+        remove: {
+          primary: "remover",
+          alternatives: ["eliminar", "apagar", "remova"],
+          normalized: "remove"
+        },
+        put: { primary: "colocar", alternatives: ["p\xF4r", "por", "coloque"], normalized: "put" },
         append: { primary: "anexar", normalized: "append" },
         prepend: { primary: "preceder", normalized: "prepend" },
-        take: { primary: "pegar", normalized: "take" },
+        take: { primary: "pegar", alternatives: ["pegue"], normalized: "take" },
         make: { primary: "fazer", alternatives: ["criar"], normalized: "make" },
         clone: { primary: "clonar", alternatives: [], normalized: "clone" },
         swap: { primary: "trocar", alternatives: ["substituir"], normalized: "swap" },
         morph: { primary: "transformar", alternatives: ["converter"], normalized: "morph" },
-        set: { primary: "definir", alternatives: ["configurar"], normalized: "set" },
-        get: { primary: "obter", normalized: "get" },
+        set: { primary: "definir", alternatives: ["configurar", "defina"], normalized: "set" },
+        get: { primary: "obter", alternatives: ["obtenha"], normalized: "get" },
         increment: { primary: "incrementar", alternatives: ["aumentar"], normalized: "increment" },
         decrement: { primary: "decrementar", alternatives: ["diminuir"], normalized: "decrement" },
         log: { primary: "registrar", alternatives: ["imprimir"], normalized: "log" },
         show: { primary: "mostrar", alternatives: ["exibir"], normalized: "show" },
-        hide: { primary: "ocultar", alternatives: ["esconder"], normalized: "hide" },
+        hide: { primary: "ocultar", alternatives: ["esconder", "esconda"], normalized: "hide" },
         transition: { primary: "transi\xE7\xE3o", alternatives: ["animar"], normalized: "transition" },
         on: { primary: "em", alternatives: ["ao"], normalized: "on" },
         trigger: { primary: "disparar", alternatives: ["ativar"], normalized: "trigger" },
@@ -8132,13 +8459,13 @@ var init_portuguese = __esm({
           alternatives: ["ponto-interrupcao"],
           normalized: "breakpoint"
         },
-        go: { primary: "ir", alternatives: ["navegar"], normalized: "go" },
+        go: { primary: "ir", alternatives: ["navegar", "v\xE1"], normalized: "go" },
         scroll: { primary: "rolar", alternatives: ["scroll"], normalized: "scroll" },
         push: { primary: "empurrar", alternatives: ["push"], normalized: "push" },
         replace: { primary: "repor", alternatives: ["recolocar"], normalized: "replace" },
         process: { primary: "processar", normalized: "process" },
         wait: { primary: "esperar", alternatives: ["aguardar"], normalized: "wait" },
-        fetch: { primary: "buscar", normalized: "fetch" },
+        fetch: { primary: "buscar", alternatives: ["busque"], normalized: "fetch" },
         settle: { primary: "estabilizar", normalized: "settle" },
         if: { primary: "se", normalized: "if" },
         // salvo — single token ('salvo se' = unless). a_menos kept as an
@@ -8161,6 +8488,27 @@ var init_portuguese = __esm({
         return: { primary: "retornar", alternatives: ["devolver"], normalized: "return" },
         then: { primary: "ent\xE3o", alternatives: ["logo"], normalized: "then" },
         and: { primary: "e", alternatives: ["tamb\xE9m", "al\xE9m disso"], normalized: "and" },
+        // Comparison operator (`target matches .x`). Without this keyword the surface
+        // stays an identifier and leaks verbatim into the condition's raw expression,
+        // which the core expression parser reads as English (modal-close-backdrop /
+        // focus-trap drop their then-branch). Not an ActionType and has no command
+        // schema, so no pattern is generated from it.
+        matches: { primary: "corresponde", normalized: "matches" },
+        // Existence operator (`if #modal exists`). Same seam as `matches`: without the
+        // keyword the surface stays an identifier and leaks verbatim into the
+        // condition's raw expression (if-exists). Neither an ActionType nor a command
+        // schema, so no pattern is generated from it.
+        exists: { primary: "existe", normalized: "exists" },
+        // Copula (`if result is false`, `if my value is empty`). Without the keyword the
+        // surface stays an identifier and leaks verbatim into the condition's raw
+        // expression, which the core expression parser reads as English. Neither an
+        // ActionType nor a command schema, so no pattern is generated from it.
+        is: { primary: "\xE9", normalized: "is" },
+        // Negative-existence operator (`if no dragHandle set dragHandle to me`). Same
+        // seam as `exists`: without the keyword the surface stays an identifier and
+        // leaks verbatim into the condition's raw expression (behavior-draggable).
+        // Neither an ActionType nor a command schema, so no pattern is generated from it.
+        no: { primary: "nenhum", normalized: "no" },
         end: { primary: "fim", alternatives: ["final", "t\xE9rmino"], normalized: "end" },
         js: { primary: "js", normalized: "js" },
         async: { primary: "ass\xEDncrono", normalized: "async" },
@@ -8267,7 +8615,10 @@ var init_quechua = __esm({
         result: "rurasqa",
         event: "ruwakuq",
         target: "punta",
-        body: "kurku"
+        body: "kurku",
+        document: "qillqa",
+        window: "k_iri",
+        detail: "sut_iy"
       },
       possessive: {
         marker: "-pa",
@@ -8338,7 +8689,10 @@ var init_quechua = __esm({
         focus: { primary: "qhawachiy", alternatives: ["qhaway"], normalized: "focus" },
         blur: { primary: "paqariy", alternatives: ["mana qhawachiy"], normalized: "blur" },
         // Phase 1 (v0.9.90): DOM / form state / debug
-        empty: { primary: "ch'usaq", normalized: "empty" },
+        // Batch 3: apostrophe-less chusaq added — the i18n dict renders the empty
+        // COMMAND with it (its `is empty` expression word), which parsed null against
+        // the ch'usaq-only command patterns.
+        empty: { primary: "ch'usaq", alternatives: ["chusaq"], normalized: "empty" },
         open: { primary: "paskay", normalized: "open" },
         close: { primary: "wichqay", normalized: "close" },
         select: { primary: "marcay", normalized: "select" },
@@ -8376,6 +8730,22 @@ var init_quechua = __esm({
         return: { primary: "kutichiy", alternatives: ["kutimuy"], normalized: "return" },
         then: { primary: "chaymantataq", alternatives: ["hinaspa", "chaymanta"], normalized: "then" },
         and: { primary: "hinallataq", alternatives: ["ima", "chaymantawan"], normalized: "and" },
+        // Comparison operator (`target matches .x`). Without this keyword the surface
+        // stays an identifier and leaks verbatim into the condition's raw expression,
+        // which the core expression parser reads as English (modal-close-backdrop /
+        // focus-trap drop their then-branch). Not an ActionType and has no command
+        // schema, so no pattern is generated from it.
+        matches: { primary: "tupan", normalized: "matches" },
+        // Existence operator (`if #modal exists`). Same seam as `matches`: without the
+        // keyword the surface stays an identifier and leaks verbatim into the
+        // condition's raw expression (if-exists). Neither an ActionType nor a command
+        // schema, so no pattern is generated from it.
+        exists: { primary: "tiyan", normalized: "exists" },
+        // Copula (`if result is false`, `if my value is empty`). Without the keyword the
+        // surface stays an identifier and leaks verbatim into the condition's raw
+        // expression, which the core expression parser reads as English. Neither an
+        // ActionType nor a command schema, so no pattern is generated from it.
+        is: { primary: "kanqa", normalized: "is" },
         end: { primary: "tukukuy", alternatives: ["tukuy", "puchukay"], normalized: "end" },
         js: { primary: "js", normalized: "js" },
         async: { primary: "mana waqtalla", normalized: "async" },
@@ -8471,8 +8841,11 @@ var init_russian = __esm({
         result: "\u0440\u0435\u0437\u0443\u043B\u044C\u0442\u0430\u0442",
         event: "\u0441\u043E\u0431\u044B\u0442\u0438\u0435",
         target: "\u0446\u0435\u043B\u044C",
-        body: "\u0442\u0435\u043B\u043E"
+        body: "\u0442\u0435\u043B\u043E",
         // was an English placeholder; the i18n dict emits the Russian word
+        document: "\u0434\u043E\u043A\u0443\u043C\u0435\u043D\u0442",
+        window: "\u043E\u043A\u043D\u043E",
+        detail: "\u0434\u0435\u0442\u0430\u043B\u0438"
       },
       possessive: {
         marker: "",
@@ -8718,6 +9091,21 @@ var init_russian = __esm({
         // so `target соответствует .x` must normalize to `target matches .x`; otherwise
         // `соответствует` stays an identifier and modal-close-backdrop drops its then-branch.
         matches: { primary: "\u0441\u043E\u043E\u0442\u0432\u0435\u0442\u0441\u0442\u0432\u0443\u0435\u0442", normalized: "matches" },
+        // Existence operator (`if #modal exists`). Same seam as `matches`: without the
+        // keyword the surface stays an identifier and leaks verbatim into the
+        // condition's raw expression (if-exists). Neither an ActionType nor a command
+        // schema, so no pattern is generated from it.
+        exists: { primary: "\u0441\u0443\u0449\u0435\u0441\u0442\u0432\u0443\u0435\u0442", normalized: "exists" },
+        // Copula (`if result is false`, `if my value is empty`). Without the keyword the
+        // surface stays an identifier and leaks verbatim into the condition's raw
+        // expression, which the core expression parser reads as English. Neither an
+        // ActionType nor a command schema, so no pattern is generated from it.
+        is: { primary: "\u0435\u0441\u0442\u044C", normalized: "is" },
+        // Negative-existence operator (`if no dragHandle set dragHandle to me`). Same
+        // seam as `exists`: without the keyword the surface stays an identifier and
+        // leaks verbatim into the condition's raw expression (behavior-draggable).
+        // Neither an ActionType nor a command schema, so no pattern is generated from it.
+        no: { primary: "\u043D\u0435\u0442", normalized: "no" },
         end: { primary: "\u043A\u043E\u043D\u0435\u0446", normalized: "end" },
         // Advanced
         js: { primary: "js", normalized: "js" },
@@ -8834,7 +9222,10 @@ var init_swahili = __esm({
         result: "matokeo",
         event: "tukio",
         target: "lengo",
-        body: "mwili"
+        body: "mwili",
+        document: "hati",
+        window: "dirisha",
+        detail: "maelezo"
       },
       possessive: {
         marker: "",
@@ -8946,6 +9337,17 @@ var init_swahili = __esm({
         // Swahili copula ("is"); only recognized in predicate position (after a value,
         // before an adjective like `tupu`), so it doesn't disturb command parsing.
         is: { primary: "ni", normalized: "is" },
+        // Comparison operator (`target matches .x`). Without this keyword the surface
+        // stays an identifier and leaks verbatim into the condition's raw expression,
+        // which the core expression parser reads as English (modal-close-backdrop /
+        // focus-trap drop their then-branch). Not an ActionType and has no command
+        // schema, so no pattern is generated from it.
+        matches: { primary: "inafanana", normalized: "matches" },
+        // Negative-existence operator (`if no dragHandle set dragHandle to me`). Same
+        // seam as `exists`: without the keyword the surface stays an identifier and
+        // leaks verbatim into the condition's raw expression (behavior-draggable).
+        // Neither an ActionType nor a command schema, so no pattern is generated from it.
+        no: { primary: "hakuna", normalized: "no" },
         end: { primary: "mwisho", alternatives: ["maliza", "tamati"], normalized: "end" },
         js: { primary: "js", alternatives: ["javascript"], normalized: "js" },
         async: { primary: "isiyo sawia", normalized: "async" },
@@ -9139,6 +9541,11 @@ var init_thai = __esm({
         return: { primary: "\u0E04\u0E37\u0E19\u0E04\u0E48\u0E32", alternatives: ["\u0E01\u0E25\u0E31\u0E1A"], normalized: "return" },
         then: { primary: "\u0E41\u0E25\u0E49\u0E27", alternatives: [], normalized: "then" },
         and: { primary: "\u0E41\u0E25\u0E30", alternatives: [], normalized: "and" },
+        // Existence operator (`if #modal exists`). Same seam as `matches`: without the
+        // keyword the surface stays an identifier and leaks verbatim into the
+        // condition's raw expression (if-exists). Neither an ActionType nor a command
+        // schema, so no pattern is generated from it.
+        exists: { primary: "\u0E21\u0E35\u0E2D\u0E22\u0E39\u0E48", normalized: "exists" },
         end: { primary: "\u0E08\u0E1A", alternatives: [], normalized: "end" },
         // Advanced
         js: { primary: "\u0E40\u0E08\u0E40\u0E2D\u0E2A", alternatives: ["js"], normalized: "js" },
@@ -9242,8 +9649,11 @@ var init_tl = __esm({
         // "event"
         target: "target",
         // "target"
-        body: "katawan"
+        body: "katawan",
         // was an English placeholder; the i18n dict emits the Tagalog word
+        document: "dokumento",
+        window: "bintana",
+        detail: "detalye"
       },
       possessive: {
         marker: "ng",
@@ -9351,6 +9761,17 @@ var init_tl = __esm({
         return: { primary: "ibalik", alternatives: ["bumalik"], normalized: "return" },
         then: { primary: "pagkatapos", alternatives: ["saka"], normalized: "then" },
         and: { primary: "at", normalized: "and" },
+        // Comparison operator (`target matches .x`). Without this keyword the surface
+        // stays an identifier and leaks verbatim into the condition's raw expression,
+        // which the core expression parser reads as English (modal-close-backdrop /
+        // focus-trap drop their then-branch). Not an ActionType and has no command
+        // schema, so no pattern is generated from it.
+        matches: { primary: "tumutugma", normalized: "matches" },
+        // Copula (`if result is false`, `if my value is empty`). Without the keyword the
+        // surface stays an identifier and leaks verbatim into the condition's raw
+        // expression, which the core expression parser reads as English. Neither an
+        // ActionType nor a command schema, so no pattern is generated from it.
+        is: { primary: "ay", normalized: "is" },
         end: { primary: "wakas", alternatives: ["tapos"], normalized: "end" },
         // Advanced
         js: { primary: "js", normalized: "js" },
@@ -9450,7 +9871,10 @@ var init_turkish = __esm({
         result: "sonu\xE7",
         event: "olay",
         target: "hedef",
-        body: "g\xF6vde"
+        body: "g\xF6vde",
+        document: "belge",
+        window: "pencere",
+        detail: "detay"
       },
       possessive: {
         // Genitive suffix, spaced for tokenization like Turkish's other case
@@ -9512,7 +9936,10 @@ var init_turkish = __esm({
         // 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" },
+        // `ile` is the free-standing instrumental the transformer actually emits
+        // for with-phrases (`getir method:"POST" body:form ile`); the suffix
+        // forms cover hand-written agglutinated variants.
+        style: { primary: "le", alternatives: ["la", "yle", "yla", "ile"], position: "after" },
         // Instrumental
         event: { primary: "i", alternatives: ["\u0131", "u", "\xFC"], position: "after" }
         // Event as accusative
@@ -9609,6 +10036,24 @@ var init_turkish = __esm({
         and: { primary: "ve", alternatives: ["ayr\u0131ca", "hem de"], normalized: "and" },
         or: { primary: "veya", normalized: "or" },
         not: { primary: "de\u011Fil", alternatives: ["degil"], normalized: "not" },
+        // Comparison operator (`target matches .x`). Without this keyword the surface
+        // stays an identifier and leaks verbatim into the condition's raw expression,
+        // which the core expression parser reads as English (modal-close-backdrop /
+        // focus-trap drop their then-branch). Not an ActionType and has no command
+        // schema, so no pattern is generated from it.
+        matches: { primary: "e\u015Fle\u015Fir", normalized: "matches" },
+        // Copula (`if result is false`, `if my value is empty`). Without the keyword the
+        // surface stays an identifier and leaks verbatim into the condition's raw
+        // expression, which the core expression parser reads as English. Neither an
+        // ActionType nor a command schema, so no pattern is generated from it.
+        is: { primary: "dir", normalized: "is" },
+        // Negative-existence operator (`if no dragHandle set dragHandle to me`). Same
+        // seam as `exists`: without the keyword the surface stays an identifier and
+        // leaks verbatim into the condition's raw expression (behavior-draggable).
+        // Neither an ActionType nor a command schema, so no pattern is generated from it.
+        // `yok` is a prefix of `else: 'yoksa'`; the keyword walk sorts longest-first, so
+        // `yoksa` still wins where it appears.
+        no: { primary: "yok", normalized: "no" },
         end: { primary: "son", alternatives: ["biti\u015F", "bitti"], normalized: "end" },
         // Advanced
         js: { primary: "js", normalized: "js" },
@@ -9703,8 +10148,11 @@ var init_ukrainian = __esm({
         result: "\u0440\u0435\u0437\u0443\u043B\u044C\u0442\u0430\u0442",
         event: "\u043F\u043E\u0434\u0456\u044F",
         target: "\u0446\u0456\u043B\u044C",
-        body: "\u0442\u0456\u043B\u043E"
+        body: "\u0442\u0456\u043B\u043E",
         // was an English placeholder; the i18n dict emits the Ukrainian word
+        document: "\u0434\u043E\u043A\u0443\u043C\u0435\u043D\u0442",
+        window: "\u0432\u0456\u043A\u043D\u043E",
+        detail: "\u0434\u0435\u0442\u0430\u043B\u0456"
       },
       possessive: {
         marker: "",
@@ -9968,6 +10416,21 @@ var init_ukrainian = __esm({
         // so `target відповідає .x` must normalize to `target matches .x`; otherwise
         // `відповідає` stays an identifier and modal-close-backdrop drops its then-branch.
         matches: { primary: "\u0432\u0456\u0434\u043F\u043E\u0432\u0456\u0434\u0430\u0454", normalized: "matches" },
+        // Existence operator (`if #modal exists`). Same seam as `matches`: without the
+        // keyword the surface stays an identifier and leaks verbatim into the
+        // condition's raw expression (if-exists). Neither an ActionType nor a command
+        // schema, so no pattern is generated from it.
+        exists: { primary: "\u0456\u0441\u043D\u0443\u0454", normalized: "exists" },
+        // Copula (`if result is false`, `if my value is empty`). Without the keyword the
+        // surface stays an identifier and leaks verbatim into the condition's raw
+        // expression, which the core expression parser reads as English. Neither an
+        // ActionType nor a command schema, so no pattern is generated from it.
+        is: { primary: "\u0454", normalized: "is" },
+        // Negative-existence operator (`if no dragHandle set dragHandle to me`). Same
+        // seam as `exists`: without the keyword the surface stays an identifier and
+        // leaks verbatim into the condition's raw expression (behavior-draggable).
+        // Neither an ActionType nor a command schema, so no pattern is generated from it.
+        no: { primary: "\u043D\u0456", normalized: "no" },
         end: { primary: "\u043A\u0456\u043D\u0435\u0446\u044C", normalized: "end" },
         // Advanced
         js: { primary: "js", normalized: "js" },
@@ -10212,6 +10675,12 @@ var init_vietnamese = __esm({
         return: { primary: "tr\u1EA3 v\u1EC1", normalized: "return" },
         then: { primary: "r\u1ED3i", alternatives: ["sau \u0111\xF3", "th\xEC"], normalized: "then" },
         and: { primary: "v\xE0", normalized: "and" },
+        // Comparison operator (`target matches .x`). Without this keyword the surface
+        // stays an identifier and leaks verbatim into the condition's raw expression,
+        // which the core expression parser reads as English (modal-close-backdrop /
+        // focus-trap drop their then-branch). Not an ActionType and has no command
+        // schema, so no pattern is generated from it.
+        matches: { primary: "kh\u1EDBp", normalized: "matches" },
         end: { primary: "k\u1EBFt th\xFAc", normalized: "end" },
         // Advanced
         js: { primary: "js", normalized: "js" },
@@ -10306,7 +10775,10 @@ var init_chinese = __esm({
         result: "\u7ED3\u679C",
         event: "\u4E8B\u4EF6",
         target: "\u76EE\u6807",
-        body: "\u4E3B\u4F53"
+        body: "\u4E3B\u4F53",
+        document: "\u6587\u6863",
+        window: "\u7A97\u53E3",
+        detail: "\u8BE6\u60C5"
       },
       possessive: {
         marker: "\u7684",
@@ -10413,6 +10885,11 @@ var init_chinese = __esm({
         return: { primary: "\u8FD4\u56DE", normalized: "return" },
         then: { primary: "\u7136\u540E", alternatives: ["\u63A5\u7740", "\u90A3\u4E48"], normalized: "then" },
         and: { primary: "\u5E76\u4E14", alternatives: ["\u548C", "\u800C\u4E14"], normalized: "and" },
+        // Existence operator (`if #modal exists`). Same seam as `matches`: without the
+        // keyword the surface stays an identifier and leaks verbatim into the
+        // condition's raw expression (if-exists). Neither an ActionType nor a command
+        // schema, so no pattern is generated from it.
+        exists: { primary: "\u5B58\u5728", normalized: "exists" },
         end: { primary: "\u7ED3\u675F", alternatives: ["\u7EC8\u6B62", "\u5B8C"], normalized: "end" },
         // Advanced
         js: { primary: "JS\u6267\u884C", alternatives: ["js"], normalized: "js" },
@@ -10908,8 +11385,22 @@ var init_schema_validator = __esm({
       "select",
       "clear",
       "reset",
-      "breakpoint"
+      "breakpoint",
       // Zero-arg debug command
+      // Feature blocks. Their meaning lives in the BODY, not in a head role: `live`
+      // and `intercept` have no head at all, and eventsource/socket/worker's name and
+      // url are structural, not semantic arguments. Giving them roles purely to make
+      // `scoreRoleCoverage` return a non-vacuous number would inject new
+      // `action.role:valueType` entries into the English R1 reference that all 23
+      // other languages must also capture, or the role-fidelity ratchet fires. The
+      // structural layer (`tryParseFeatureBlock`) parses them instead, and derives
+      // confidence from the body — so the `maxScore === 0 → 1` shortcut is never the
+      // thing that scores them.
+      "live",
+      "eventsource",
+      "socket",
+      "worker",
+      "intercept"
     ]);
   }
 });
@@ -10953,7 +11444,7 @@ function getSchema(action) {
 function getDefinedSchemas() {
   return Object.values(commandSchemas).filter((s) => s.roles.length > 0 || s.bareKeyword === true);
 }
-var toggleSchema, addSchema, removeSchema, putSchema, setSchema, bindSchema, liveSchema, eventsourceSchema, socketSchema, workerSchema, interceptSchema, showSchema, hideSchema, onSchema, triggerSchema, waitSchema, fetchSchema, incrementSchema, decrementSchema, appendSchema, prependSchema, logSchema, getCommandSchema, takeSchema, makeSchema, haltSchema, settleSchema, throwSchema, sendSchema, ifSchema, unlessSchema, elseSchema, repeatSchema, forSchema, whileSchema, continueSchema, goSchema, transitionSchema, cloneSchema, focusSchema, blurSchema, emptySchema, openSchema, closeSchema, selectSchema, clearSchema, resetSchema, breakpointSchema, callSchema, returnSchema, jsSchema, asyncSchema, tellSchema, defaultSchema, initSchema, behaviorSchema, installSchema, measureSchema, swapSchema, morphSchema, beepSchema, breakSchema, copySchema, exitSchema, pickSchema, scrollSchema, URL_MARKER_ALL_LANGS, PARTIALS_IN_MARKER_ALL_LANGS, pushSchema, replaceSchema, processSchema, renderSchema, commandSchemas;
+var toggleSchema, addSchema, removeSchema, putSchema, setSchema, bindSchema, liveSchema, eventsourceSchema, socketSchema, workerSchema, interceptSchema, showSchema, hideSchema, onSchema, triggerSchema, waitSchema, fetchSchema, incrementSchema, decrementSchema, appendSchema, prependSchema, logSchema, getCommandSchema, takeSchema, makeSchema, haltSchema, settleSchema, throwSchema, sendSchema, ifSchema, unlessSchema, elseSchema, repeatSchema, forSchema, whileSchema, continueSchema, URL_MARKER_ALL_LANGS, goSchema, transitionSchema, cloneSchema, focusSchema, blurSchema, emptySchema, openSchema, closeSchema, selectSchema, clearSchema, resetSchema, breakpointSchema, callSchema, returnSchema, jsSchema, asyncSchema, tellSchema, defaultSchema, initSchema, behaviorSchema, installSchema, measureSchema, swapSchema, morphSchema, beepSchema, breakSchema, copySchema, exitSchema, pickSchema, scrollSchema, PARTIALS_IN_MARKER_ALL_LANGS, pushSchema, replaceSchema, processSchema, renderSchema, commandSchemas;
 var init_command_schemas = __esm({
   "src/generators/command-schemas.ts"() {
     toggleSchema = {
@@ -11045,8 +11536,53 @@ var init_command_schemas = __esm({
           default: { type: "reference", value: "me" },
           svoPosition: 2,
           sovPosition: 1,
-          markerOverride: { en: "to" }
-          // "add .class to #element"
+          // `add` is directional, but every profile's `destination` marker is
+          // LOCATIVE (en on, es en, ar على, zh 在, fr sur, de auf, pt em) because
+          // it also serves `toggle`/`show`. Without a per-language override the
+          // rendered text said "add .class ON #element" in every language but
+          // English — the gap lokascript-learn corrects with 6 of its 16 override
+          // entries. ja に / ko 에 / tr e are already directional, so they keep
+          // the profile default.
+          //
+          // Tier B (2.9): he/id/it/sw were the remaining locatives that this
+          // language actually distinguishes.
+          //   he — `על` is "ON"; Hebrew adds with the allative `אל` (`ל` is a bound
+          //        prefix, so it cannot stand as a separate marker token).
+          //   id — `pada` is "at/on"; `ke` is the directional, and it is what the
+          //        i18n corpus already renders for every id destination.
+          //   it — `in` is locative; Italian adds with `a` (`aggiungere a`).
+          //   sw — `kwenye` is not merely locative, it is sw's EVENT keyword
+          //        (`on: 'kwenye'` in the dictionary), so reusing it as a
+          //        destination marker collides. `kwa` is the corpus rendering.
+          // hi `में` / ru+uk `в` / th `ใน` / vi `vào` are already the right
+          // container-directional for "add to", and keep the profile default.
+          markerOverride: {
+            en: "to",
+            es: "a",
+            ar: "\u0625\u0644\u0649",
+            zh: "\u5230",
+            fr: "\xE0",
+            de: "zu",
+            pt: "a",
+            he: "\u05D0\u05DC",
+            id: "ke",
+            it: "a",
+            sw: "kwa"
+          },
+          // Each language's previous primary marker (and its alternates) still
+          // parses, so source written against ≤2.8 keeps working.
+          markerLegacy: {
+            es: ["en", "sobre", "hacia"],
+            ar: ["\u0639\u0644\u0649", "\u0641\u064A", "\u0628"],
+            zh: ["\u5728", "\u4E8E"],
+            fr: ["sur", "dans"],
+            de: ["auf", "in"],
+            pt: ["em", "para"],
+            he: ["\u05E2\u05DC", "\u05D1", "\u05DC"],
+            id: ["pada", "di"],
+            it: ["in", "su"],
+            sw: ["kwenye"]
+          }
         }
       ],
       // Runtime error documentation
@@ -11136,12 +11672,39 @@ var init_command_schemas = __esm({
           svoPosition: 2,
           sovPosition: 2,
           // SOV: destination comes second (に/에/a marker)
-          markerOverride: { en: "into" },
-          // "put 'hello' into #output"
+          // "put 'hello' into #output" — directional, so the same locative-default
+          // correction as `add`. es `en` and pt `em` are already right for "into",
+          // as are ja に / ko 에 / tr e; only ar/zh/fr/de need an override.
+          //
+          // Tier B (2.9): `put` is ILLATIVE, so it diverges from `add` where the
+          // two senses differ. he takes `ב` ("in/into" — `שים ב`), NOT the allative
+          // `אל` that `add`/`go` take. it keeps its locative `in` (`mettere in`) —
+          // it is `add`/`go` that needed `a`. id/sw change for the same reason as
+          // `add` (directional / event-keyword collision). hi `में`, ru+uk `в`,
+          // th `ใน` and vi `vào` are all already the illative.
+          markerOverride: {
+            en: "into",
+            ar: "\u0641\u064A",
+            zh: "\u5230",
+            fr: "dans",
+            de: "in",
+            he: "\u05D1",
+            id: "ke",
+            sw: "kwa"
+          },
           // `before` / `after` are alternate position markers; the matched marker
           // is recorded as a literal in the `method` role (a derived role with no
           // surface form of its own — populated by schema-driven role inference).
           markerVariants: { en: ["before", "after"] },
+          markerLegacy: {
+            ar: ["\u0639\u0644\u0649", "\u0625\u0644\u0649", "\u0628"],
+            zh: ["\u5728", "\u4E8E"],
+            fr: ["sur", "\xE0"],
+            de: ["auf", "zu"],
+            he: ["\u05E2\u05DC", "\u05D0\u05DC", "\u05DC"],
+            id: ["pada", "di"],
+            sw: ["kwenye"]
+          },
           methodCarrier: "method"
         }
       ],
@@ -11276,8 +11839,11 @@ var init_command_schemas = __esm({
           // ending in a vowel (`doğru ya` = "true" in set-attribute). markerOverride
           // is a single string, so the generated tr set patterns carried only `e`
           // and set-attribute fell to the role-scrambling generic SOV extraction.
-          // markerVariants supplies the allomorphs the SOV two-role generators merge
-          // in as marker alternatives. See STRUCTURAL_ARCS_ROADMAP.md (tr set-attribute).
+          // markerVariants supplies the allomorphs, merged in as marker alternatives.
+          // Until 2026-07-25 only the SOV two-role generators merged them, so this
+          // worked ONLY inside an event handler: `@disabled i doğru ya ayarla` did
+          // not parse as a bare command while `tıklama da @disabled i doğru ya
+          // ayarla` did. See STRUCTURAL_ARCS_ROADMAP.md (tr set-attribute).
           markerVariants: {
             tr: ["e", "a", "ye", "ya"]
           }
@@ -11402,7 +11968,13 @@ var init_command_schemas = __esm({
           role: "source",
           description: "The element or property to bind to",
           required: true,
-          expectedTypes: ["selector", "reference", "expression"],
+          // 'property-path' opts this role into the "of"-possessive matcher, so the
+          // property-first render of `bind $x to #y's prop` (es `valor de #picker`,
+          // ar `قيمة لـ #picker`) keeps its owner selector instead of collapsing to
+          // the bare property word; see pattern-matcher tryMatchOfPossessiveExpression.
+          // The selector-first languages (en `#picker's value`, ja `#pickerの 値`)
+          // already reached property-path through tryMatchPossessiveSelectorExpression.
+          expectedTypes: ["selector", "reference", "expression", "property-path"],
           svoPosition: 2,
           sovPosition: 2,
           // Element mirrors `set`/`add`/`put`'s value ("to") marking per language.
@@ -11589,7 +12161,15 @@ var init_command_schemas = __esm({
           expectedTypes: ["literal", "expression"],
           // expression for custom/namespaced event names
           svoPosition: 1,
-          sovPosition: 2
+          sovPosition: 2,
+          // hi/qu/bn mark trigger's event ACCUSATIVELY (`draggable:start को ट्रिगर`,
+          // `draggable:start ta kichay`, `draggable:start কে ট্রিগার` — the corpus
+          // renderings), but their profile-wide event marker is the on-handler one
+          // (hi पर, qu locative pi, bn এ), so the generated SOV pattern never
+          // matched and the whole line fell through to the on-handler reading (hi)
+          // or failed outright (qu/bn). ja/ko were immune only because their event
+          // marker IS the object particle (を / 을·를). #588 markerVariants machinery.
+          markerVariants: { hi: ["\u0915\u094B"], qu: ["ta"], bn: ["\u0995\u09C7"] }
         },
         {
           role: "destination",
@@ -11635,14 +12215,26 @@ var init_command_schemas = __esm({
           renderOverride: { en: "" }
           // "fetch /api" (rendering — no preposition)
         },
+        {
+          role: "style",
+          description: "Request options object (method, headers, body, credentials\u2026)",
+          required: false,
+          // expression-ONLY: the pattern matcher routes a `{ … }` run in an
+          // expression-only slot through its object-literal fold, which preserves the
+          // source text so the expression parser can build a real objectLiteral.
+          // `style` is the role whose marker is `with` in every language profile.
+          expectedTypes: ["expression"],
+          svoPosition: 2,
+          sovPosition: 2
+        },
         {
           role: "responseType",
           description: "Response format (json, text, html, blob, etc.)",
           required: false,
           expectedTypes: ["literal", "expression"],
           // json/text/html are identifiers → expression type
-          svoPosition: 2,
-          sovPosition: 2,
+          svoPosition: 3,
+          sovPosition: 3,
           markerOverride: { en: "as" }
           // "fetch /api as json" — needed by schema-driven role inference
         },
@@ -11651,16 +12243,16 @@ var init_command_schemas = __esm({
           description: "HTTP method (GET, POST, etc.)",
           required: false,
           expectedTypes: ["literal"],
-          svoPosition: 3,
-          sovPosition: 3
+          svoPosition: 4,
+          sovPosition: 4
         },
         {
           role: "destination",
           description: "Where to store the result",
           required: false,
           expectedTypes: ["selector", "reference"],
-          svoPosition: 4,
-          sovPosition: 4
+          svoPosition: 5,
+          sovPosition: 5
         }
       ]
     };
@@ -12144,6 +12736,32 @@ var init_command_schemas = __esm({
       roles: []
       // No roles
     };
+    URL_MARKER_ALL_LANGS = {
+      en: "url",
+      es: "url",
+      pt: "url",
+      fr: "url",
+      de: "url",
+      it: "url",
+      ja: "url",
+      ko: "url",
+      zh: "url",
+      ar: "url",
+      he: "url",
+      hi: "url",
+      bn: "url",
+      tr: "url",
+      ru: "url",
+      uk: "url",
+      pl: "url",
+      id: "url",
+      vi: "url",
+      th: "url",
+      ms: "url",
+      tl: "url",
+      sw: "url",
+      qu: "url"
+    };
     goSchema = {
       action: "go",
       description: "Navigate to a URL",
@@ -12157,17 +12775,113 @@ var init_command_schemas = __esm({
           expectedTypes: ["literal", "expression"],
           svoPosition: 1,
           sovPosition: 1,
-          markerOverride: { en: "to" },
-          // "go to /page" (parsing)
-          renderOverride: { en: "" },
-          // "go /page" (rendering — no preposition)
+          // "go to /page" (parsing). Directional, so the same locative-default
+          // correction as `add`/`put`.
+          //
+          // Tier B (2.9): `go` is pure ALLATIVE — motion toward a target — so it
+          // needs the directional in more languages than `add`/`put` do, including
+          // ones where a container-locative was fine for those two.
+          //   he — `אל` ("toward"), as `add`; `לך על url` read "go ON url".
+          //   hi — `पर`: Hindi navigates to a page with `पर जाएं`; `में` is
+          //        "go INTO", which is entering a place, not opening a URL.
+          //   id — `ke`, as `add`.
+          //   it — `a`: `andare a` for a specific target (`andare in` is for
+          //        regions — `andare in Italia`).
+          //   ru/uk — `на`: `перейти на сторінку` is the navigation idiom; `в`
+          //        ("into") is right for `add`/`put` but not for opening a page.
+          //   sw — `kwa`, as `add`.
+          // th is NOT here — it renders bare, with zh and vi; see below.
+          markerOverride: {
+            en: "to",
+            es: "a",
+            ar: "\u0625\u0644\u0649",
+            fr: "\xE0",
+            de: "zu",
+            pt: "para",
+            he: "\u05D0\u05DC",
+            hi: "\u092A\u0930",
+            id: "ke",
+            it: "a",
+            ru: "\u043D\u0430",
+            sw: "kwa",
+            uk: "\u043D\u0430"
+          },
+          // "go /page" (rendering — no preposition).
+          //
+          // zh, vi and th render BARE.
+          //
+          // zh and vi because their `go` keyword already encodes the direction, so
+          // any destination marker is a second one: zh `前往` is "proceed-to"
+          // (`前往 到 url` = "proceed-to to url") and vi `đi đến` is literally
+          // "go to" (`đi đến vào url` = "go-to into url"). Both are corrected in
+          // the i18n corpus in the same change
+          // (`patterns-reference/scripts/fix-translations.sql`).
+          //
+          // th because Thai motion verbs take a BARE destination — `ไปบ้าน`
+          // ("go home"), `ไปโรงเรียน` ("go school") — so `ไป url` is the idiomatic
+          // form. The profile default rendered `ไป ใน url` ("go IN url"), which is
+          // what needed fixing; the obvious replacement `ยัง` (giving the formal
+          // `ไปยัง`) is rejected because `ยัง` is also the very common adverb
+          // "still/yet", and the V4 vocab gate correctly refuses to classify it as
+          // a particle — promoting it would mis-tokenize ordinary Thai.
+          //
+          // Parsing is unaffected for all three: none has a `markerOverride`, so
+          // each stays on the profile-default branch and keeps accepting its old
+          // markers (th `ใน` / `ไปยัง`) from the profile itself.
+          renderOverride: { en: "", zh: "", vi: "", th: "" },
           // `go back` renders the destination bare in en (history nav has no `to`),
           // and he/zh render it with their PATIENT marker (לך את back / 前往 把 back)
           // while go-url keeps the destination marker (לך על url / 前往 到 url) —
           // the corpus is ground truth, so en's `to` is optional and he/zh accept
           // the patient particle as a destination-marker alternative, scoped to go.
-          markerOptional: { en: true },
-          markerVariants: { he: ["\u05D0\u05EA"], zh: ["\u628A"] }
+          // The render side drops the preposition for these four, so the parse
+          // side cannot require it: `go /page`, `前往 url`, `đi đến url`, `ไป url`
+          // must parse alongside the marked forms the profile still accepts.
+          markerOptional: { en: true, zh: true, vi: true, th: true },
+          // zh renders `前往 把 back` with its PATIENT particle before go's
+          // destination — a synonym here, not a distinct shape, so it is accepted as
+          // a marker alternative scoped to go. he's `את` is the same thing and sits
+          // in `markerLegacy` below: it moved there in #763 because the two fields
+          // were then read by DIFFERENT branches, so leaving it here silently
+          // stopped `לך את back` parsing the moment he gained a `markerOverride`.
+          // Both fields now merge on both branches (`schemaMarkerAlternatives`), so
+          // that trap is gone and the split is historical.
+          markerVariants: { zh: ["\u628A"] },
+          markerLegacy: {
+            es: ["en", "sobre", "hacia"],
+            ar: ["\u0639\u0644\u0649", "\u0641\u064A", "\u0628"],
+            fr: ["sur", "dans"],
+            de: ["auf", "in"],
+            pt: ["em", "a"],
+            // `את` is he's PATIENT particle, which the transformer renders before
+            // go's destination in `go back` (`לך את back`) — a parse-only synonym
+            // here, never rendered, which is exactly what markerLegacy is for.
+            he: ["\u05E2\u05DC", "\u05D1", "\u05DC", "\u05D0\u05EA"],
+            hi: ["\u092E\u0947\u0902"],
+            id: ["pada", "di"],
+            it: ["in", "su"],
+            ru: ["\u0432", "\u043A"],
+            sw: ["kwenye"],
+            uk: ["\u0432", "\u0434\u043E"]
+            // zh, vi and th are NOT listed: none has a markerOverride, so all three
+            // stay on the profile-default branch and keep accepting their old
+            // markers from the profile itself. Only their RENDERING changed.
+            // Listing them here would be dead config — markerLegacy is read ONLY by
+            // the override branch.
+          }
+        }
+      ],
+      // `go to url "/page"` — without this variant the destination captures the
+      // bare word `url` and the actual URL is dropped as tolerated-trailing text,
+      // in en and therefore in every render (the go-url corpus row). The required
+      // `url` literal keeps the variant inert for `go back` / scroll forms.
+      rolePrefixLiteralVariants: [
+        {
+          role: "destination",
+          literal: URL_MARKER_ALL_LANGS,
+          idSuffix: "url",
+          priorityDelta: 5,
+          methodCarrier: "method"
         }
       ]
     };
@@ -12799,7 +13513,27 @@ var init_command_schemas = __esm({
             th: "\u0E14\u0E49\u0E27\u0E22",
             vi: "v\u1EDBi",
             he: "\u05E2\u05DD",
-            zh: "\u7528"
+            zh: "\u7528",
+            // SOV/postpositional with-words. These follow the patient (`#b से`,
+            // `#b দিয়ে`), matching the i18n `with` emission. Without them the SOV
+            // patient-first swap pattern's trailing group (which binds the second
+            // element to `destination`) had only the locative dest-marker (hi में,
+            // bn তে) as its alternatives, so `#b <with-word>` never bound and #b
+            // dropped — hi/bn/tr/qu rendered the invalid `swap with #a`. ja/ko
+            // escaped only because their dest-marker alternatives already carry the
+            // instrumental (で / 로). See generateSOVPatientFirstEventHandlerPattern.
+            hi: "\u0938\u0947",
+            bn: "\u09A6\u09BF\u09AF\u09BC\u09C7",
+            tr: "ile",
+            qu: "wan",
+            // VSO with-words. The corpus puts the with-element AFTER the event
+            // (`استبدل #a عند نقر بـ#b`, `palitan_pwesto #a kapag click nang #b`);
+            // the vso-verb-first generator's swap-gated trailing group binds it to
+            // `destination` via these words. ar's `بـ` is the bi-proclitic + tatweel
+            // exactly as the ArabicProcliticExtractor emits it (glued to a selector
+            // sigil). See generateVSOVerbFirstEventHandlerPattern.
+            ar: "\u0628\u0640",
+            tl: "nang"
           }
         }
       ]
@@ -12888,13 +13622,13 @@ var init_command_schemas = __esm({
     };
     pickSchema = {
       action: "pick",
-      description: "Select a random element from a collection",
+      description: "Select item(s), character(s), a range, first/last/random N, or regex matches from a root",
       category: "variable",
       primaryRole: "patient",
       roles: [
         {
           role: "patient",
-          description: "The items to pick from",
+          description: "The range/count/index/regex argument to pick",
           required: true,
           expectedTypes: ["literal", "expression", "reference"],
           svoPosition: 1,
@@ -12902,7 +13636,7 @@ var init_command_schemas = __esm({
         },
         {
           role: "source",
-          description: 'The array to pick from (with "from" keyword)',
+          description: 'The root to pick from (with "of"/"from" keyword)',
           required: false,
           expectedTypes: ["reference", "expression"],
           svoPosition: 2,
@@ -12944,32 +13678,6 @@ var init_command_schemas = __esm({
         }
       ]
     };
-    URL_MARKER_ALL_LANGS = {
-      en: "url",
-      es: "url",
-      pt: "url",
-      fr: "url",
-      de: "url",
-      it: "url",
-      ja: "url",
-      ko: "url",
-      zh: "url",
-      ar: "url",
-      he: "url",
-      hi: "url",
-      bn: "url",
-      tr: "url",
-      ru: "url",
-      uk: "url",
-      pl: "url",
-      id: "url",
-      vi: "url",
-      th: "url",
-      ms: "url",
-      tl: "url",
-      sw: "url",
-      qu: "url"
-    };
     PARTIALS_IN_MARKER_ALL_LANGS = {
       en: "partials in",
       es: "partials in",
@@ -13162,7 +13870,7 @@ var init_command_schemas = __esm({
         roles: []
       }
     };
-    if (typeof process !== "undefined" && process.env.NODE_ENV !== "production") {
+    if (typeof process !== "undefined" && process.env.LOKASCRIPT_SCHEMA_VALIDATION === "1") {
       Promise.resolve().then(() => (init_schema_validator(), schema_validator_exports)).then(({ validateAllSchemas: validateAllSchemas2, formatValidationResults: formatValidationResults2 }) => {
         const validations = validateAllSchemas2(commandSchemas);
         if (validations.size > 0) {
@@ -14643,17 +15351,48 @@ var init_generic_extractors = __esm({
 });
 
 // src/tokenizers/extractors/css-selector.ts
+function consumePseudoSegments(input, pos2) {
+  let end = pos2;
+  while (end < input.length && input[end] === ":") {
+    const m = input.slice(end).match(/^::?[a-zA-Z][a-zA-Z0-9-]*/);
+    if (!m) break;
+    let segEnd = end + m[0].length;
+    if (input[segEnd] === "(") {
+      let depth = 0;
+      let p = segEnd;
+      while (p < input.length) {
+        if (input[p] === "(") depth++;
+        else if (input[p] === ")") {
+          depth--;
+          if (depth === 0) {
+            p++;
+            break;
+          }
+        }
+        p++;
+      }
+      if (depth !== 0) break;
+      segEnd = p;
+    }
+    end = segEnd;
+  }
+  return end;
+}
 function extractCssSelector(input, position) {
   const char = input[position];
   if (char === "#") {
     const match = input.slice(position).match(/^#[a-zA-Z_][\w-]*/);
-    return match ? match[0] : null;
+    if (!match) return null;
+    const end = consumePseudoSegments(input, position + match[0].length);
+    return input.slice(position, end);
   }
   if (char === ".") {
     const dynamic = input.slice(position).match(/^\.\{[a-zA-Z_$][\w$]*\}/);
     if (dynamic) return dynamic[0];
     const match = input.slice(position).match(/^\.[a-zA-Z_][\w-]*/);
-    return match ? match[0] : null;
+    if (!match) return null;
+    const end = consumePseudoSegments(input, position + match[0].length);
+    return input.slice(position, end);
   }
   if (char === "@") {
     const match = input.slice(position).match(/^@[a-zA-Z_][\w-]*/);
@@ -14671,7 +15410,8 @@ function extractCssSelector(input, position) {
       if (input[end] === "]") {
         depth--;
         if (depth === 0) {
-          return input.slice(position, end + 1);
+          const pseudoEnd = consumePseudoSegments(input, end + 1);
+          return input.slice(position, pseudoEnd);
         }
       }
       end++;
@@ -14679,7 +15419,9 @@ function extractCssSelector(input, position) {
     return null;
   }
   if (char === "<") {
-    const match = input.slice(position).match(/^<(?=[\w.#[])[\w-]*(?:[#.][\w-]+|\[[^\]]+\])*\s*\/>/);
+    const match = input.slice(position).match(
+      /^<(?=[\w.#[])[\w-]*(?:[#.][\w-]+|\[[^\]]+\]|::?[a-zA-Z][a-zA-Z0-9-]*(?:\([^)]*\))?)*\s*\/>/
+    );
     return match ? match[0] : null;
   }
   return null;
@@ -14745,29 +15487,38 @@ var init_event_modifier = __esm({
 });
 
 // src/tokenizers/extractors/url.ts
+function findInterpolationEnd(input, start) {
+  let depth = 1;
+  for (let i = start; i < input.length; i++) {
+    const ch = input[i];
+    if (ch === "{") depth++;
+    else if (ch === "}" && --depth === 0) return i + 1;
+  }
+  return -1;
+}
 function extractUrl(input, position) {
   const remaining = input.slice(position);
-  if (remaining.startsWith("http://") || remaining.startsWith("https://")) {
-    const match = remaining.match(/^https?:\/\/[^\s]*/);
-    return match ? match[0] : null;
-  }
-  if (remaining.startsWith("//")) {
-    const match = remaining.match(/^\/\/[^\s]*/);
-    return match ? match[0] : null;
-  }
-  if (remaining.startsWith("./") || remaining.startsWith("../")) {
-    const match = remaining.match(/^\.\.?\/[^\s]*/);
-    return match ? match[0] : null;
-  }
-  if (remaining.startsWith("/")) {
-    const match = remaining.match(/^\/[^\s]*/);
-    return match ? match[0] : null;
+  const prefix = URL_PREFIXES.find((p) => remaining.startsWith(p));
+  if (!prefix) return null;
+  let i = prefix.length;
+  while (i < remaining.length) {
+    const ch = remaining[i];
+    if (ch === "$" && remaining[i + 1] === "{") {
+      const end = findInterpolationEnd(remaining, i + 2);
+      if (end !== -1) {
+        i = end;
+        continue;
+      }
+    }
+    if (/\s/.test(ch)) break;
+    i++;
   }
-  return null;
+  return remaining.slice(0, i);
 }
-var UrlExtractor;
+var URL_PREFIXES, UrlExtractor;
 var init_url = __esm({
   "src/tokenizers/extractors/url.ts"() {
+    URL_PREFIXES = ["http://", "https://", "//", "./", "../", "/"];
     UrlExtractor = class {
       constructor() {
         this.name = "url";
@@ -15860,6 +16611,18 @@ var init_arabic_proclitic = __esm({
           checkPos++;
         }
         if (remainingLength < 2) {
+          const runIsTatweelOnly = remainingLength >= 1 && input.slice(nextPos, checkPos).split("").every((c) => c === "\u0640");
+          const followChar = input[checkPos];
+          if (entry.type === "preposition" && runIsTatweelOnly && (followChar === "#" || followChar === ".")) {
+            return {
+              value: input.slice(position, checkPos),
+              length: checkPos - position,
+              metadata: {
+                procliticType: entry.type,
+                normalized: entry.normalized
+              }
+            };
+          }
           return null;
         }
         return {
@@ -16240,6 +17003,17 @@ var init_hindi_keyword = __esm({
             pos2 = extPos;
           }
         }
+        if (this.context && input[pos2] === "_" && pos2 + 1 < input.length && isDevanagari(input[pos2 + 1])) {
+          let extPos = pos2;
+          let ext = word;
+          while (extPos < input.length && (input[extPos] === "_" || isDevanagari(input[extPos]))) {
+            ext += input[extPos++];
+          }
+          if (this.context.lookupKeyword(ext)) {
+            word = ext;
+            pos2 = extPos;
+          }
+        }
         if (!word) return null;
         const keywordEntry = this.context.lookupKeyword(word);
         const normalized2 = keywordEntry && keywordEntry.normalized !== keywordEntry.native ? keywordEntry.normalized : void 0;
@@ -16301,9 +17075,11 @@ var init_hindi_particle = __esm({
       }
       setContext(context) {
         this._context = context;
-        void this._context;
       }
       canExtract(input, position) {
+        if (this.underscoreJoinedKeyword(input, position)) {
+          return false;
+        }
         for (const [particle] of COMPOUND_POSTPOSITIONS) {
           if (input.startsWith(particle, position)) {
             return true;
@@ -16317,7 +17093,27 @@ var init_hindi_particle = __esm({
         }
         return SINGLE_POSTPOSITIONS.has(word);
       }
+      /**
+       * True when the Devanagari run at `position` is `_`-joined into a keyword the
+       * profile/EXTRAS registered (के_रूप_में). See the note in canExtract.
+       */
+      underscoreJoinedKeyword(input, position) {
+        if (!this._context) return false;
+        let pos2 = position;
+        while (pos2 < input.length && this.isDevanagari(input[pos2])) pos2++;
+        if (input[pos2] !== "_" || pos2 + 1 >= input.length || !this.isDevanagari(input[pos2 + 1])) {
+          return false;
+        }
+        let ext = input.slice(position, pos2);
+        while (pos2 < input.length && (input[pos2] === "_" || this.isDevanagari(input[pos2]))) {
+          ext += input[pos2++];
+        }
+        return Boolean(this._context.lookupKeyword(ext));
+      }
       extract(input, position) {
+        if (this.underscoreJoinedKeyword(input, position)) {
+          return null;
+        }
         for (const [particle, metadata2] of COMPOUND_POSTPOSITIONS) {
           if (input.startsWith(particle, position)) {
             return {
@@ -16941,6 +17737,17 @@ var init_indonesian_keyword = __esm({
         while (pos2 < input.length && isIndonesianIdentifierChar(input[pos2])) {
           word += input[pos2++];
         }
+        if (this.context && pos2 < input.length && input[pos2] === "_") {
+          let extPos = pos2;
+          let ext = word;
+          while (extPos < input.length && (input[extPos] === "_" || isIndonesianIdentifierChar(input[extPos]))) {
+            ext += input[extPos++];
+          }
+          if (this.context.lookupKeyword(ext.toLowerCase())) {
+            word = ext;
+            pos2 = extPos;
+          }
+        }
         if (!word) return null;
         const lower = word.toLowerCase();
         const isPreposition = PREPOSITIONS5.has(lower);
@@ -17391,14 +18198,16 @@ var init_quechua_keyword = __esm({
             metadata: { suffixValue: hyphenSuffix.toLowerCase() }
           };
         }
-        const maxKeywordLen = 12;
+        const maxKeywordLen = 13;
         for (let len = Math.min(maxKeywordLen, input.length - startPos); len >= 2; len--) {
           const candidate = input.slice(startPos, startPos + len);
           const after = input[startPos + len];
           if (after !== void 0 && isQuechuaLetter(after)) continue;
           let allQuechua = true;
           for (let i = 0; i < candidate.length; i++) {
-            if (!isQuechuaLetter(candidate[i])) {
+            const ch = candidate[i];
+            if (ch === "_" && i > 0 && i < candidate.length - 1) continue;
+            if (!isQuechuaLetter(ch)) {
               allQuechua = false;
               break;
             }
@@ -18285,6 +19094,12 @@ var init_japanese2 = __esm({
       { native: "\u524D", normalized: "previous" },
       { native: "\u6700\u3082\u8FD1\u3044", normalized: "closest" },
       { native: "\u89AA", normalized: "parent" },
+      // Containment (`first <button/> in .modal`): the i18n dict emits の中, which
+      // otherwise splits の(particle) + 中(identifier) — the stray identifier broke
+      // the generated focus pattern's operand run (focus-trap Family G; tr/bn/hi
+      // work because their in-word is one token). Whole-token entry mirrors en's
+      // keyword `in` mid-run geometry.
+      { native: "\u306E\u4E2D", normalized: "in" },
       // Events
       { native: "\u30AF\u30EA\u30C3\u30AF", normalized: "click" },
       { native: "\u5909\u66F4", normalized: "change" },
@@ -18313,6 +19128,14 @@ var init_japanese2 = __esm({
       // References (alternative forms not in profile)
       { native: "\u79C1", normalized: "me" },
       // Alternative to 自分 (jibun)
+      // The i18n dict emits 対象 for `target` while the profile carries ターゲット, so the
+      // word the authored corpus actually uses did not lex as a keyword and leaked into
+      // the condition's raw expression (`if 対象 一致する .modal-backdrop`). Additive: the
+      // profile's ターゲット stays registered. Must land WITH the `matches` keyword —
+      // fixing the operand alone leaves the operator leaking and vice versa (see the
+      // R2 note in japanese.ts's profile `matches` entry).
+      { native: "\u5BFE\u8C61", normalized: "target" },
+      // Alternative to ターゲット (the dict's word)
       // Note: Attached particle forms (を切り替え, を追加, etc.) are intentionally NOT included
       // because they would cause ambiguous parsing. The separate particle + verb pattern
       // (を + 切り替え) is preferred for consistent semantic analysis.
@@ -18324,7 +19147,11 @@ var init_japanese2 = __esm({
       { native: "\u79D2", normalized: "s" },
       { native: "\u30DF\u30EA\u79D2", normalized: "ms" },
       { native: "\u5206", normalized: "m" },
-      { native: "\u6642\u9593", normalized: "h" }
+      { native: "\u6642\u9593", normalized: "h" },
+      { native: "\u542B\u3080", normalized: "inclusive" },
+      { native: "\u9664\u304F", normalized: "exclusive" },
+      { native: "\u6587\u5B57", normalized: "characters" },
+      { native: "\u30E9\u30F3\u30C0\u30E0", normalized: "random" }
     ];
     JapaneseTokenizer = class extends BaseTokenizer {
       constructor() {
@@ -18758,6 +19585,11 @@ var init_korean2 = __esm({
       { native: "\uAC70\uC9D3", normalized: "false" },
       { native: "\uB110", normalized: "null" },
       { native: "\uBBF8\uC815\uC758", normalized: "undefined" },
+      // The corpus authors 정의안됨 ("not defined") for undefined (behavior-removable/
+      // sortable `만약 X 이다 정의안됨`); without a whole-token entry it shatters into
+      // 정 + 의안됨, leaking the invalid `is 정 의안됨`. Longest-first scan (cap 6)
+      // matches the 4-char compound whole, like 마우스다운 above.
+      { native: "\uC815\uC758\uC548\uB428", normalized: "undefined" },
       // Positional
       { native: "\uCCAB\uBC88\uC9F8", normalized: "first" },
       { native: "\uB9C8\uC9C0\uB9C9", normalized: "last" },
@@ -18765,6 +19597,11 @@ var init_korean2 = __esm({
       { native: "\uC774\uC804", normalized: "previous" },
       { native: "\uAC00\uC7A5\uAC00\uAE4C\uC6B4", normalized: "closest" },
       { native: "\uBD80\uBAA8", normalized: "parent" },
+      // Containment (`first <button/> in .modal`): the i18n dict emits 안에, which
+      // otherwise splits 안(identifier) + 에(particle) — the stray identifier broke
+      // the generated focus pattern's operand run (focus-trap Family G). Whole-token
+      // entry mirrors en's keyword `in` mid-run geometry.
+      { native: "\uC548\uC5D0", normalized: "in" },
       // Events
       { native: "\uD074\uB9AD", normalized: "click" },
       { native: "\uB354\uBE14\uD074\uB9AD", normalized: "dblclick" },
@@ -18797,7 +19634,11 @@ var init_korean2 = __esm({
       { native: "\uCD08", normalized: "s" },
       { native: "\uBC00\uB9AC\uCD08", normalized: "ms" },
       { native: "\uBD84", normalized: "m" },
-      { native: "\uC2DC\uAC04", normalized: "h" }
+      { native: "\uC2DC\uAC04", normalized: "h" },
+      { native: "\uD3EC\uD568", normalized: "inclusive" },
+      { native: "\uC81C\uC678", normalized: "exclusive" },
+      { native: "\uBB38\uC790", normalized: "characters" },
+      { native: "\uBB34\uC791\uC704", normalized: "random" }
     ];
     KoreanTokenizer = class extends BaseTokenizer {
       constructor() {
@@ -19066,6 +19907,17 @@ var init_arabic2 = __esm({
       // ka- (like, as)
     ]);
     ARABIC_EXTRAS = [
+      // References (alternative forms not in profile). The i18n dict emits the BARE
+      // nouns هدف/نتيجة while the profile carries the definite-article forms
+      // الهدف/النتيجة, so the words the authored corpus actually uses did not lex as
+      // keywords and leaked into the condition's raw expression (`if هدف يطابق …`).
+      // Additive: the profile's الهدف/النتيجة stay registered. Same direction as the
+      // profile's `body: 'جسم'` note — align to what the dict emits, never the reverse
+      // (the dict wins on regeneration, so profile→dict is the convergent direction).
+      { native: "\u0647\u062F\u0641", normalized: "target" },
+      // Alternative to الهدف (the dict's word)
+      { native: "\u0646\u062A\u064A\u062C\u0629", normalized: "result" },
+      // Alternative to النتيجة (the dict's word)
       // Values/Literals
       { native: "\u0635\u062D\u064A\u062D", normalized: "true" },
       { native: "\u062E\u0637\u0623", normalized: "false" },
@@ -19130,13 +19982,17 @@ var init_arabic2 = __esm({
       { native: "\u062D\u064A\u0646", normalized: "on" },
       { native: "\u0644\u0645\u0651\u0627", normalized: "on" },
       { native: "\u0644\u0645\u0627", normalized: "on" },
-      { native: "\u0644\u062F\u0649", normalized: "on" }
+      { native: "\u0644\u062F\u0649", normalized: "on" },
       //
       // Command spelling variants are now in the profile alternatives:
       // - toggle: بدل, غيّر, غير (in profile)
       // - add: اضف, زِد (in profile)
       // - remove: أزل, امسح (in profile)
       // - etc.
+      { native: "\u0634\u0627\u0645\u0644", normalized: "inclusive" },
+      { native: "\u062D\u0635\u0631\u064A", normalized: "exclusive" },
+      { native: "\u062D\u0631\u0648\u0641", normalized: "characters" },
+      { native: "\u0639\u0634\u0648\u0627\u0626\u064A", normalized: "random" }
     ];
     ArabicTokenizer = class extends BaseTokenizer {
       constructor() {
@@ -19220,7 +20076,7 @@ var init_arabic2 = __esm({
             pos2++;
           }
         }
-        return new TokenStreamImpl(tokens, this.language);
+        return new TokenStreamImpl(this.mergeColonQualifiedNames(tokens), this.language);
       }
       classifyToken(token) {
         if (CONJUNCTIONS2.has(token)) return "conjunction";
@@ -19571,12 +20427,16 @@ var init_spanish_keyword = __esm({
         const keywordEntry = this.context.lookupKeyword(word);
         const normalized2 = keywordEntry && keywordEntry.normalized !== keywordEntry.native ? keywordEntry.normalized : void 0;
         let morphNormalized;
+        let morphStem;
+        let morphConfidence;
         if (!keywordEntry && this.context.normalizer) {
           const morphResult = this.context.normalizer.normalize(word);
           if (morphResult.stem !== word && morphResult.confidence >= 0.7) {
             const stemEntry = this.context.lookupKeyword(morphResult.stem);
             if (stemEntry) {
               morphNormalized = stemEntry.normalized;
+              morphStem = morphResult.stem;
+              morphConfidence = morphResult.confidence;
             }
           }
         }
@@ -19585,6 +20445,8 @@ var init_spanish_keyword = __esm({
           length: pos2 - position,
           metadata: {
             normalized: normalized2 || morphNormalized,
+            stem: morphStem,
+            stemConfidence: morphConfidence,
             isPreposition
           }
         };
@@ -19664,8 +20526,12 @@ var init_spanish2 = __esm({
       // Reference alternatives (accent variation, synonym)
       { native: "m\xED", normalized: "me" },
       // Accented form of mi
-      { native: "destino", normalized: "target" }
+      { native: "destino", normalized: "target" },
       // Synonym for objetivo
+      { native: "inclusivo", normalized: "inclusive" },
+      { native: "exclusivo", normalized: "exclusive" },
+      { native: "caracteres", normalized: "characters" },
+      { native: "aleatorio", normalized: "random" }
     ];
     SpanishTokenizer = class extends BaseTokenizer {
       constructor() {
@@ -20122,6 +20988,19 @@ var init_turkish2 = __esm({
       { native: "farebirak", normalized: "mouseup" },
       { native: "kayd\u0131r", normalized: "scroll" },
       { native: "kaydir", normalized: "scroll" },
+      // resize/scroll nominal forms: listed in eventNameTranslations (which only
+      // the SOV-extraction path consults) but not registered as keywords — so a
+      // fused *-sov-simple match captured them RAW (`boyutlandırma de çağır` →
+      // event:expression:boyutlandırma, the window-resize R1 flip once the
+      // debounced-head junk no longer forced the SOV-extraction path). Keyword
+      // entries normalize them at the token, the same route the healthy natives
+      // (tıklama→click) take.
+      { native: "boyutland\u0131rma", normalized: "resize" },
+      { native: "boyutlandirma", normalized: "resize" },
+      { native: "boyutland\u0131r", normalized: "resize" },
+      { native: "boyutlandir", normalized: "resize" },
+      { native: "kayd\u0131rma", normalized: "scroll" },
+      { native: "kaydirma", normalized: "scroll" },
       { native: "tu\u015F_bas", normalized: "keydown" },
       { native: "tus_bas", normalized: "keydown" },
       { native: "tu\u015F_b\u0131rak", normalized: "keyup" },
@@ -20130,7 +21009,11 @@ var init_turkish2 = __esm({
       { native: "saniye", normalized: "s" },
       { native: "milisaniye", normalized: "ms" },
       { native: "dakika", normalized: "m" },
-      { native: "saat", normalized: "h" }
+      { native: "saat", normalized: "h" },
+      { native: "dahil", normalized: "inclusive" },
+      { native: "hari\xE7", normalized: "exclusive" },
+      { native: "karakterler", normalized: "characters" },
+      { native: "rastgele", normalized: "random" }
     ];
     TurkishTokenizer = class extends BaseTokenizer {
       constructor() {
@@ -20309,7 +21192,16 @@ var init_chinese2 = __esm({
       { native: "\u524D", normalized: "before" },
       { native: "\u540E", normalized: "after" },
       { native: "\u90A3\u4E48", normalized: "then" },
-      { native: "\u5B8C", normalized: "end" }
+      { native: "\u5B8C", normalized: "end" },
+      // Connectives. Whole-token so the greedy longest-first walk claims the 2-char
+      // 作为 (`as`) before its 1-char tail 为 can match the `for` command primary —
+      // without it `作为 Number` shattered into `作` + `为`→`for` (`computed-value`).
+      // The reverse render (CONNECTIVE_LEXICON.zh) already maps 作为→as.
+      { native: "\u4F5C\u4E3A", normalized: "as" },
+      { native: "\u5305\u542B", normalized: "inclusive" },
+      { native: "\u6392\u9664", normalized: "exclusive" },
+      { native: "\u5B57\u7B26", normalized: "characters" },
+      { native: "\u968F\u673A", normalized: "random" }
     ];
     ChineseTokenizer = class extends BaseTokenizer {
       constructor() {
@@ -20674,12 +21566,16 @@ var init_portuguese_keyword = __esm({
         const keywordEntry = this.context.lookupKeyword(lower);
         const normalized2 = keywordEntry && keywordEntry.normalized !== keywordEntry.native ? keywordEntry.normalized : void 0;
         let morphNormalized;
+        let morphStem;
+        let morphConfidence;
         if (!keywordEntry && this.context.normalizer) {
           const morphResult = this.context.normalizer.normalize(word);
           if (morphResult.stem !== word && morphResult.confidence >= 0.7) {
             const stemEntry = this.context.lookupKeyword(morphResult.stem);
             if (stemEntry) {
               morphNormalized = stemEntry.normalized;
+              morphStem = morphResult.stem;
+              morphConfidence = morphResult.confidence;
             }
           }
         }
@@ -20688,6 +21584,8 @@ var init_portuguese_keyword = __esm({
           length: pos2 - position,
           metadata: {
             normalized: normalized2 || morphNormalized,
+            stem: morphStem,
+            stemConfidence: morphConfidence,
             isPreposition
           }
         };
@@ -20811,7 +21709,11 @@ var init_portuguese2 = __esm({
       { native: "padrao", normalized: "default" },
       { native: "at\xE9 que", normalized: "until" },
       // Multi-word phrases
-      { native: "dentro de", normalized: "into" }
+      { native: "dentro de", normalized: "into" },
+      { native: "inclusivo", normalized: "inclusive" },
+      { native: "exclusivo", normalized: "exclusive" },
+      { native: "caracteres", normalized: "characters" },
+      { native: "aleat\xF3rio", normalized: "random" }
     ];
     PortugueseTokenizer = class extends BaseTokenizer {
       constructor() {
@@ -21163,12 +22065,16 @@ var init_french_keyword = __esm({
         const keywordEntry = this.context.lookupKeyword(lower);
         const normalized2 = keywordEntry && keywordEntry.normalized !== keywordEntry.native ? keywordEntry.normalized : void 0;
         let morphNormalized;
+        let morphStem;
+        let morphConfidence;
         if (!keywordEntry && this.context.normalizer) {
           const morphResult = this.context.normalizer.normalize(word);
           if (morphResult.stem !== word && morphResult.confidence >= 0.7) {
             const stemEntry = this.context.lookupKeyword(morphResult.stem);
             if (stemEntry) {
               morphNormalized = stemEntry.normalized;
+              morphStem = morphResult.stem;
+              morphConfidence = morphResult.confidence;
             }
           }
         }
@@ -21177,6 +22083,8 @@ var init_french_keyword = __esm({
           length: pos2 - position,
           metadata: {
             normalized: normalized2 || morphNormalized,
+            stem: morphStem,
+            stemConfidence: morphConfidence,
             isPreposition
           }
         };
@@ -21275,7 +22183,11 @@ var init_french2 = __esm({
       // Additional morph synonym
       { native: "transmuter", normalized: "morph" },
       // Multi-word phrases
-      { native: "tant que", normalized: "while" }
+      { native: "tant que", normalized: "while" },
+      { native: "inclusif", normalized: "inclusive" },
+      { native: "exclusif", normalized: "exclusive" },
+      { native: "caract\xE8res", normalized: "characters" },
+      { native: "al\xE9atoire", normalized: "random" }
     ];
     FrenchTokenizer = class extends BaseTokenizer {
       constructor() {
@@ -21716,7 +22628,11 @@ var init_german2 = __esm({
       // Verb conjugation variants (imperatives for test cases)
       { native: "erh\xF6he", normalized: "increment" },
       { native: "erhohe", normalized: "increment" },
-      { native: "verringere", normalized: "decrement" }
+      { native: "verringere", normalized: "decrement" },
+      { native: "inklusiv", normalized: "inclusive" },
+      { native: "exklusiv", normalized: "exclusive" },
+      { native: "Zeichen", normalized: "characters" },
+      { native: "zuf\xE4llig", normalized: "random" }
     ];
     GermanTokenizer = class extends BaseTokenizer {
       constructor() {
@@ -21813,12 +22729,27 @@ var init_indonesian2 = __esm({
       // outside
     ]);
     INDONESIAN_EXTRAS = [
+      // window-resize compound: the dict emits underscore-joined ubah_ukuran
+      // (resize), which the `_` split shattered into ubah(→change) + _ + ukuran —
+      // the event slot normalized to `change` and `_ ukuran` dropped unconsumed
+      // (Arc F). Whole-token entry mirrors qu's hatun_kay precedent (quechua.ts).
+      { native: "ubah_ukuran", normalized: "resize" },
+      // behavior-draggable's `no` operator: the dict emits underscore-joined
+      // tidak_ada, which the `_` split shattered into tidak(→not) + _ + ada(→exists).
+      // Whole-token entry mirrors ubah_ukuran above; the keyword walk sorts
+      // longest-first, so `tidak_ada` (9) beats `tidak` (5).
+      { native: "tidak_ada", normalized: "no" },
       // Values/Literals
       { native: "benar", normalized: "true" },
       { native: "salah", normalized: "false" },
       { native: "null", normalized: "null" },
       { native: "kosong", normalized: "null" },
       { native: "tidakdidefinisikan", normalized: "undefined" },
+      // The corpus authors `tidak_terdefinisi` for undefined (behavior-removable/
+      // sortable `jika X adalah tidak_terdefinisi`); without a whole-token entry the
+      // `_` split shatters it into tidak(→not) + `_ terdefinisi`, leaking the
+      // invalid `is not _ terdefinisi`. Same shape as tidak_ada above.
+      { native: "tidak_terdefinisi", normalized: "undefined" },
       // Positional
       { native: "pertama", normalized: "first" },
       { native: "terakhir", normalized: "last" },
@@ -21849,7 +22780,11 @@ var init_indonesian2 = __esm({
       { native: "atau", normalized: "or" },
       { native: "tidak", normalized: "not" },
       { native: "adalah", normalized: "is" },
-      { native: "ada", normalized: "exists" }
+      { native: "ada", normalized: "exists" },
+      { native: "inklusif", normalized: "inclusive" },
+      { native: "eksklusif", normalized: "exclusive" },
+      { native: "karakter", normalized: "characters" },
+      { native: "acak", normalized: "random" }
     ];
     IndonesianTokenizer = class extends BaseTokenizer {
       constructor() {
@@ -22064,7 +22999,7 @@ var init_quechua2 = __esm({
         this.name = "quechua-string-literal";
       }
       canExtract(input, position) {
-        return input[position] === '"' || input[position] === "'";
+        return input[position] === '"' || input[position] === "'" || input[position] === "`";
       }
       extract(input, position) {
         const quote = input[position];
@@ -22123,6 +23058,8 @@ var init_quechua2 = __esm({
       // (set-attribute `@disabled ta cheqaq man …`); without it the value tokenized
       // as a bare identifier and `set @disabled to <undefined>` ran. arí/ari ("yes")
       // are the colloquial alternates, kept for input tolerance.
+      // Pick unit word (arc 3) — mirrors the i18n dict's `characters: 'sanampa'`.
+      { native: "sanampa", normalized: "characters" },
       { native: "cheqaq", normalized: "true" },
       { native: "ar\xED", normalized: "true" },
       { native: "ari", normalized: "true" },
@@ -22157,6 +23094,31 @@ var init_quechua2 = __esm({
       // aswan-prefixed compound splits (the suffix extractor strips -wan from
       // 'aswan'). The i18n dict emits bare 'kaylla' (near/close).
       { native: "kaylla", normalized: "closest" },
+      // Containment (`first <button/> in .modal`): the i18n dict emits ukupi,
+      // which otherwise splits uku(identifier) + pi — and the stranded `pi`
+      // mis-reads as the EVENT marker (the ñawpaqpi/qhepapi class above; same
+      // longest-first cure). Whole-token entry mirrors en's keyword `in` mid-run
+      // geometry (focus-trap Family G).
+      { native: "ukupi", normalized: "in" },
+      // window-resize compounds: the dict emits underscore-joined k_iri (window)
+      // and hatun_kay (resize), which the `_` split shattered into junk role
+      // fragments (call.source:literal="k_iri" destination:literal="hatun_" —
+      // the qu window-resize R1 row; hatun_kay sits in eventNameTranslations but
+      // never arrived whole). The ñawpaq_kaq entry above is the precedent.
+      { native: "k_iri", normalized: "window" },
+      { native: "hatun_kay", normalized: "resize" },
+      // behavior-draggable's `no` operator: the dict emits underscore-joined
+      // mana_kanchu, which the `_` split shattered into mana(→not/without) + _ +
+      // kanchu. Same whole-token shape as hatun_kay; longest-first makes
+      // `mana_kanchu` (11) beat `mana` (4).
+      { native: "mana_kanchu", normalized: "no" },
+      // `undefined`: the dict emits underscore-joined `mana_riqsisqa` ("not known"),
+      // which the `_` split shattered into mana(→false) + _ + riqsisqa — rendering
+      // `is false _ riqsisqa` and breaking the canonical parse (behavior-removable/qu,
+      // behavior-sortable/qu `if triggerEl is undefined`). The bare `mana riqsisqa`
+      // (space) entry above never fires — the corpus authors the underscore form.
+      // Same whole-token shape as mana_kanchu; longest-first makes it beat `mana`.
+      { native: "mana_riqsisqa", normalized: "undefined" },
       { native: "qaylla", normalized: "closest" },
       { native: "tayta", normalized: "parent" },
       // Events
@@ -22218,7 +23180,8 @@ var init_quechua2 = __esm({
       { native: "qhawachiy", normalized: "focus" },
       { native: "mana qhawachiy", normalized: "blur" },
       // Suffix modifiers
-      { native: "-manta", normalized: "from" }
+      { native: "-manta", normalized: "from" },
+      { native: "imaymanata", normalized: "random" }
     ];
     QuechuaTokenizer = class extends BaseTokenizer {
       constructor() {
@@ -22246,7 +23209,7 @@ var init_quechua2 = __esm({
           return "event-modifier";
         if (token.startsWith("#") || token.startsWith(".") || token.startsWith("[") || token.startsWith("*") || token.startsWith("<"))
           return "selector";
-        if (token.startsWith('"')) return "literal";
+        if (token.startsWith('"') || token.startsWith("'")) return "literal";
         if (/^\d/.test(token)) return "literal";
         if (["==", "!=", "<=", ">=", "<", ">", "&&", "||", "!"].includes(token)) return "operator";
         return "identifier";
@@ -22315,6 +23278,12 @@ var init_swahili2 = __esm({
       // between
     ]);
     SWAHILI_EXTRAS = [
+      // window-resize compound: the dict emits underscore-joined badilisha_ukubwa
+      // (resize), which the `_` split shattered into badilisha(→toggle!) + _ +
+      // ukubwa — the event slot normalized to `toggle` and `_ ukubwa` dropped
+      // unconsumed (Arc F). Whole-token entry mirrors qu's hatun_kay precedent
+      // (quechua.ts).
+      { native: "badilisha_ukubwa", normalized: "resize" },
       // Values/Literals
       { native: "kweli", normalized: "true" },
       { native: "uongo", normalized: "false" },
@@ -22388,7 +23357,9 @@ var init_swahili2 = __esm({
       { native: "si", normalized: "not" },
       { native: "ni", normalized: "is" },
       { native: "ipo", normalized: "exists" },
-      { native: "tupu", normalized: "empty" }
+      { native: "tupu", normalized: "empty" },
+      { native: "herufi", normalized: "characters" },
+      { native: "nasibu", normalized: "random" }
     ];
     SwahiliTokenizer = class extends BaseTokenizer {
       constructor() {
@@ -23072,7 +24043,11 @@ var init_italian2 = __esm({
       { native: "vuoto", normalized: "empty" },
       // Synonyms not in profile
       { native: "toggle", normalized: "toggle" },
-      { native: "di", normalized: "tell" }
+      { native: "di", normalized: "tell" },
+      { native: "inclusivo", normalized: "inclusive" },
+      { native: "esclusivo", normalized: "exclusive" },
+      { native: "caratteri", normalized: "characters" },
+      { native: "casuale", normalized: "random" }
     ];
     ItalianTokenizer = class extends BaseTokenizer {
       constructor() {
@@ -23177,7 +24152,11 @@ var init_vietnamese2 = __esm({
       { native: "t\u1ED3n t\u1EA1i", normalized: "exists" },
       { native: "r\u1ED7ng", normalized: "empty" },
       // English synonyms
-      { native: "javascript", normalized: "js" }
+      { native: "javascript", normalized: "js" },
+      { native: "bao g\u1ED3m", normalized: "inclusive" },
+      { native: "lo\u1EA1i tr\u1EEB", normalized: "exclusive" },
+      { native: "k\xFD t\u1EF1", normalized: "characters" },
+      { native: "ng\u1EABu nhi\xEAn", normalized: "random" }
     ];
     VietnameseTokenizer = class extends BaseTokenizer {
       constructor() {
@@ -23560,7 +24539,11 @@ var init_polish2 = __esm({
       { native: "jest", normalized: "is" },
       { native: "istnieje", normalized: "exists" },
       { native: "pusty", normalized: "empty" },
-      { native: "puste", normalized: "empty" }
+      { native: "puste", normalized: "empty" },
+      { native: "w\u0142\u0105cznie", normalized: "inclusive" },
+      { native: "wy\u0142\u0105cznie", normalized: "exclusive" },
+      { native: "znaki", normalized: "characters" },
+      { native: "losowy", normalized: "random" }
     ];
     PolishTokenizer = class extends BaseTokenizer {
       constructor() {
@@ -23990,6 +24973,12 @@ var init_russian2 = __esm({
       { native: "\u043B\u043E\u0436\u044C", normalized: "false" },
       { native: "null", normalized: "null" },
       { native: "\u043D\u0435\u043E\u043F\u0440\u0435\u0434\u0435\u043B\u0435\u043D\u043E", normalized: "undefined" },
+      // `ничего` ("nothing") is the word the corpus author uses for a null
+      // comparison (`если item есть ничего` → `if item is null`). Without it the
+      // literal leaked verbatim and the canonical parser rejected the render
+      // (behavior-sortable/ru). Its sibling `неопределено`→undefined was already
+      // registered; this closes the null half.
+      { native: "\u043D\u0438\u0447\u0435\u0433\u043E", normalized: "null" },
       // Time units (not in profile - handled by number parser)
       { native: "\u0441\u0435\u043A\u0443\u043D\u0434\u0430", normalized: "s" },
       { native: "\u0441\u0435\u043A\u0443\u043D\u0434\u044B", normalized: "s" },
@@ -24035,8 +25024,11 @@ var init_russian2 = __esm({
       // feminine
       { native: "\u043C\u043E\u0451", normalized: "my" },
       // neuter
-      { native: "\u043C\u043E\u0438", normalized: "my" }
+      { native: "\u043C\u043E\u0438", normalized: "my" },
       // plural
+      { native: "\u0432\u043A\u043B\u044E\u0447\u0438\u0442\u0435\u043B\u044C\u043D\u043E", normalized: "inclusive" },
+      { native: "\u0438\u0441\u043A\u043B\u044E\u0447\u0438\u0442\u0435\u043B\u044C\u043D\u043E", normalized: "exclusive" },
+      { native: "\u0441\u0438\u043C\u0432\u043E\u043B\u044B", normalized: "characters" }
     ];
     RussianTokenizer = class extends BaseTokenizer {
       constructor() {
@@ -24445,6 +25437,11 @@ var init_ukrainian2 = __esm({
       { native: "\u0445\u0438\u0431\u043D\u0456\u0441\u0442\u044C", normalized: "false" },
       { native: "null", normalized: "null" },
       { native: "\u043D\u0435\u0432\u0438\u0437\u043D\u0430\u0447\u0435\u043D\u043E", normalized: "undefined" },
+      // `нічого` ("nothing") is the corpus author's word for a null comparison
+      // (`якщо item є нічого` → `if item is null`); without it the literal leaked
+      // verbatim and the canonical parser rejected the render (behavior-sortable/uk).
+      // Sibling of the already-registered `невизначено`→undefined.
+      { native: "\u043D\u0456\u0447\u043E\u0433\u043E", normalized: "null" },
       // Time units (not in profile - handled by number parser)
       { native: "\u0441\u0435\u043A\u0443\u043D\u0434\u0430", normalized: "s" },
       { native: "\u0441\u0435\u043A\u0443\u043D\u0434\u0438", normalized: "s" },
@@ -24490,8 +25487,11 @@ var init_ukrainian2 = __esm({
       // feminine
       { native: "\u043C\u043E\u0454", normalized: "my" },
       // neuter
-      { native: "\u043C\u043E\u0457", normalized: "my" }
+      { native: "\u043C\u043E\u0457", normalized: "my" },
       // plural
+      { native: "\u0432\u043A\u043B\u044E\u0447\u043D\u043E", normalized: "inclusive" },
+      { native: "\u0432\u0438\u043A\u043B\u044E\u0447\u043D\u043E", normalized: "exclusive" },
+      { native: "\u0441\u0438\u043C\u0432\u043E\u043B\u0438", normalized: "characters" }
     ];
     UkrainianTokenizer = class extends BaseTokenizer {
       constructor() {
@@ -24631,7 +25631,11 @@ var init_he2 = __esm({
       { native: "\u05D3\u05E7\u05D4", normalized: "m" },
       { native: "\u05D3\u05E7\u05D5\u05EA", normalized: "m" },
       { native: "\u05E9\u05E2\u05D4", normalized: "h" },
-      { native: "\u05E9\u05E2\u05D5\u05EA", normalized: "h" }
+      { native: "\u05E9\u05E2\u05D5\u05EA", normalized: "h" },
+      { native: "\u05DB\u05D5\u05DC\u05DC", normalized: "inclusive" },
+      { native: "\u05D1\u05DC\u05E2\u05D3\u05D9", normalized: "exclusive" },
+      { native: "\u05EA\u05D5\u05D5\u05D9\u05DD", normalized: "characters" },
+      { native: "\u05D0\u05E7\u05E8\u05D0\u05D9", normalized: "random" }
     ];
     HebrewTokenizer = class extends BaseTokenizer {
       constructor() {
@@ -24788,6 +25792,12 @@ var init_hindi2 = __esm({
       // splits on it — see hi.ts events note). repeat-until-event / handler events.
       { native: "\u092E\u093E\u0909\u0938\u0928\u0940\u091A\u0947", normalized: "mousedown" },
       { native: "\u092E\u093E\u0909\u0938\u090A\u092A\u0930", normalized: "mouseup" },
+      // window-resize compound: the dict emits underscore-joined आकार_बदलें
+      // (resize), which the `_` split shattered into आकार + _ + बदलें — and the
+      // stranded बदलें (toggle verb) anchored a PHANTOM toggle command while the
+      // event slot grabbed the call target (the hi window-resize mis-parse,
+      // Arc F). Whole-token entry mirrors qu's hatun_kay precedent (quechua.ts).
+      { native: "\u0906\u0915\u093E\u0930_\u092C\u0926\u0932\u0947\u0902", normalized: "resize" },
       // Values
       { native: "\u0938\u091A", normalized: "true" },
       { native: "\u0938\u0924\u094D\u092F", normalized: "true" },
@@ -24811,7 +25821,26 @@ var init_hindi2 = __esm({
       { native: "\u0938\u094D\u0915\u094D\u0930\u0949\u0932", normalized: "scroll" },
       // Additional modifiers not in profile
       { native: "\u0915\u094B", normalized: "to" },
-      { native: "\u0915\u0947 \u0938\u093E\u0925", normalized: "with" }
+      { native: "\u0915\u0947 \u0938\u093E\u0925", normalized: "with" },
+      // Connectives. Whole-token underscore-joined surface, mirroring आकार_बदलें
+      // above: the `_` split shattered के_रूप_में (`as`) into के + _ + रूप + _ + में
+      // (`computed-value`). Registering it lets the tokenizer's underscore-recovery
+      // block adopt the whole run. The reverse render (CONNECTIVE_LEXICON.hi) already
+      // maps के_रूप_में→as; it was a documented dead entry awaiting exactly this.
+      { native: "\u0915\u0947_\u0930\u0942\u092A_\u092E\u0947\u0902", normalized: "as" },
+      // `या` (or) — dict hi.ts `or`; already matched by surface in the parser's
+      // OR_KEYWORDS (event-adjacent `or` was absorbed), but every raw-expression
+      // occurrence leaked verbatim (when-multiple-changes). Phantom-safe: `or` is
+      // neither an ActionType nor a command schema.
+      { native: "\u092F\u093E", normalized: "or" },
+      // `बदलने पर` (changes / "on changing") — dict hi.ts `changes`, SPACED whole
+      // phrase via the multi-word keyword walk (`के साथ` precedent above). NEVER
+      // register bare `बदलने`: the stem `बदल` is a registered toggle-verb
+      // alternative (patterns/toggle.ts) and the morphological normalizer strips
+      // conjugations — a bare entry re-opens the आकार_बदलें phantom-toggle class.
+      { native: "\u092C\u0926\u0932\u0928\u0947 \u092A\u0930", normalized: "changes" },
+      { native: "\u0905\u0915\u094D\u0937\u0930", normalized: "characters" },
+      { native: "\u092F\u093E\u0926\u0943\u091A\u094D\u091B\u093F\u0915", normalized: "random" }
     ];
     HindiTokenizer = class extends BaseTokenizer {
       constructor() {
@@ -24993,7 +26022,17 @@ var init_bengali2 = __esm({
       { native: "\u09B8\u09CD\u0995\u09CD\u09B0\u09CB\u09B2", normalized: "scroll" },
       // Additional modifiers not in profile
       { native: "\u0995\u09C7", normalized: "to" },
-      { native: "\u09B8\u09BE\u09A5\u09C7", normalized: "with" }
+      { native: "\u09B8\u09BE\u09A5\u09C7", normalized: "with" },
+      // Conjunctions. `অথবা` (or) — dict bn.ts `or`. Already matched by surface in the
+      // parser's OR_KEYWORDS (event-adjacent `or` was absorbed); registering it lets
+      // surfaceOf emit `or` inside raw expressions (the wait-for event list in
+      // behavior-draggable/sortable). Phantom-safe: `or` is neither an ActionType nor
+      // a command schema.
+      { native: "\u0985\u09A5\u09AC\u09BE", normalized: "or" },
+      { native: "\u0985\u09A8\u09CD\u09A4\u09B0\u09CD\u09AD\u09C1\u0995\u09CD\u09A4", normalized: "inclusive" },
+      { native: "\u09AC\u09BE\u09A6", normalized: "exclusive" },
+      { native: "\u0985\u0995\u09CD\u09B7\u09B0", normalized: "characters" },
+      { native: "\u098F\u09B2\u09CB\u09AE\u09C7\u09B2\u09CB", normalized: "random" }
     ];
     BengaliTokenizer = class extends BaseTokenizer {
       constructor() {
@@ -25067,11 +26106,19 @@ var init_thai2 = __esm({
       { native: "\u0E2D\u0E34\u0E19\u0E1E\u0E38\u0E15", normalized: "input" },
       { native: "\u0E42\u0E2B\u0E25\u0E14", normalized: "load" },
       { native: "\u0E40\u0E25\u0E37\u0E48\u0E2D\u0E19", normalized: "scroll" },
+      // `ปรับขนาด` (resize) — dict th.ts `resize`; without it the greedy scan
+      // shattered it into ป + รับ(→take) + ขนาด (window-resize/th rendered
+      // `on ป take ขนาด …`). Precedent: hi आकार_बदलें, tr boyutlandırma.
+      { native: "\u0E1B\u0E23\u0E31\u0E1A\u0E02\u0E19\u0E32\u0E14", normalized: "resize" },
       // Additional modifiers
       { native: "\u0E40\u0E27\u0E25\u0E32", normalized: "when" },
       { native: "\u0E44\u0E1B\u0E22\u0E31\u0E07", normalized: "to" },
       { native: "\u0E14\u0E49\u0E27\u0E22", normalized: "with" },
-      { native: "\u0E41\u0E25\u0E30", normalized: "and" }
+      { native: "\u0E41\u0E25\u0E30", normalized: "and" },
+      { native: "\u0E23\u0E27\u0E21", normalized: "inclusive" },
+      { native: "\u0E22\u0E01\u0E40\u0E27\u0E49\u0E19", normalized: "exclusive" },
+      { native: "\u0E2D\u0E31\u0E01\u0E02\u0E23\u0E30", normalized: "characters" },
+      { native: "\u0E2A\u0E38\u0E48\u0E21", normalized: "random" }
     ];
     ThaiTokenizer = class extends BaseTokenizer {
       constructor() {
@@ -25143,8 +26190,12 @@ var init_ms2 = __esm({
       // Alternative for input (means "enter")
       { native: "muat", normalized: "load" },
       { native: "tatal", normalized: "scroll" },
-      { native: "hover", normalized: "hover" }
+      { native: "hover", normalized: "hover" },
       // English loanword commonly used
+      { native: "inklusif", normalized: "inclusive" },
+      { native: "eksklusif", normalized: "exclusive" },
+      { native: "aksara", normalized: "characters" },
+      { native: "rawak", normalized: "random" }
     ];
     MalayTokenizer = class extends BaseTokenizer {
       constructor() {
@@ -25403,7 +26454,11 @@ var init_tl2 = __esm({
       { native: "isumite", normalized: "submit" },
       { native: "input", normalized: "input" },
       { native: "karga", normalized: "load" },
-      { native: "mag_scroll", normalized: "scroll" }
+      { native: "mag_scroll", normalized: "scroll" },
+      { native: "kasama", normalized: "inclusive" },
+      { native: "bukod", normalized: "exclusive" },
+      { native: "karakter", normalized: "characters" },
+      { native: "random", normalized: "random" }
     ];
     TagalogTokenizer = class extends BaseTokenizer {
       constructor() {
@@ -25983,6 +27038,28 @@ function getEventHandlerPatternsHi() {
         event: { marker: "\u0938\u0947", position: 2 }
       }
     },
+    // Prefix reactive `when` — the hi member of the ja/tr/ar/he when-family
+    // below (`जब $firstName या $lastName बदलने पर …`). Without it,
+    // `event-hi-bare` captured the जब token itself as the event (render
+    // `on when put …`) and dropped the subject list; en's `event-en-when`
+    // captures the first subject as the event. The event role is
+    // type-constrained so the `जब तक` while/until compound (repeat-while,
+    // unless-condition) never matches — तक lexes as a keyword/literal and
+    // declines, falling through to the repeat patterns unchanged.
+    {
+      id: "event-hi-when",
+      language: "hi",
+      command: "on",
+      priority: 95,
+      template: {
+        format: "\u091C\u092C {event} {body}",
+        tokens: [
+          { type: "literal", value: "\u091C\u092C" },
+          { type: "role", role: "event", expectedTypes: ["reference", "expression", "selector"] }
+        ]
+      },
+      extraction: { event: { position: 1 } }
+    },
     // Bare event name: क्लिक
     {
       id: "event-hi-bare",
@@ -27135,7 +28212,15 @@ var init_event_handler = __esm({
         \uBE14\uB7EC: "blur",
         \uB85C\uB4DC: "load",
         \uB9AC\uC0AC\uC774\uC988: "resize",
-        \uC2A4\uD06C\uB864: "scroll"
+        \uC2A4\uD06C\uB864: "scroll",
+        // V3c burn-down (2026-07-14): dictionary event words S5b never covered —
+        // parse-side registration so the i18n dict forms resolve (round-trip-tested).
+        \uB9C8\uC6B0\uC2A4\uC5D4\uD130: "mouseenter",
+        \uB9C8\uC6B0\uC2A4\uB9AC\uBE0C: "mouseleave",
+        \uB9C8\uC6B0\uC2A4\uBB34\uBE0C: "mousemove",
+        \uD0A4\uD504\uB808\uC2A4: "keypress",
+        \uD130\uCE58\uC885\uB8CC: "touchend",
+        \uD130\uCE58\uCDE8\uC18C: "touchcancel"
       },
       // Japanese event names → English
       ja: {
@@ -27155,7 +28240,12 @@ var init_event_handler = __esm({
         \u30ED\u30FC\u30C9: "load",
         \u8AAD\u307F\u8FBC\u307F: "load",
         \u30B5\u30A4\u30BA\u5909\u66F4: "resize",
-        \u30B9\u30AF\u30ED\u30FC\u30EB: "scroll"
+        \u30B9\u30AF\u30ED\u30FC\u30EB: "scroll",
+        // V3 Batch 2 alias: i18n dictionary form the ja tokenizer already
+        // normalizes (probe-verified).
+        \u307C\u304B\u3057: "blur"
+        // V3c burn-down (2026-07-14): dictionary event words S5b never covered —
+        // parse-side registration so the i18n dict forms resolve (round-trip-tested).
       },
       // Arabic event names → English
       ar: {
@@ -27172,7 +28262,19 @@ var init_event_handler = __esm({
         "\u062A\u0645\u0631\u064A\u0631 \u0627\u0644\u0645\u0627\u0648\u0633": "mouseover",
         \u0627\u0644\u062A\u0631\u0643\u064A\u0632: "focus",
         \u062A\u062D\u0645\u064A\u0644: "load",
-        \u062A\u0645\u0631\u064A\u0631: "scroll"
+        \u062A\u0645\u0631\u064A\u0631: "scroll",
+        // V3 Batch 2 aliases: i18n dictionary forms the ar tokenizer already
+        // normalizes (probe-verified captured values). Appended so first-wins
+        // localization canonicals above are unchanged.
+        \u062A\u0631\u0643\u064A\u0632: "focus",
+        "\u0645\u0641\u062A\u0627\u062D \u0623\u0633\u0641\u0644": "keydown",
+        "\u0645\u0641\u062A\u0627\u062D \u0623\u0639\u0644\u0649": "keyup",
+        "\u0641\u0623\u0631\u0629 \u0641\u0648\u0642": "mouseover",
+        // Arc F: the dict renders resize as the two-word تغيير حجم; the event
+        // slot captures only تغيير (→change) and حجم drops. The compound key is
+        // matched by the parser's event-compound reclaim (offset-exact join of
+        // the captured event word + the dangling fragment).
+        "\u062A\u063A\u064A\u064A\u0631 \u062D\u062C\u0645": "resize"
       },
       // Spanish event names → English
       es: {
@@ -27189,7 +28291,26 @@ var init_event_handler = __esm({
         enfoque: "focus",
         desenfoque: "blur",
         carga: "load",
-        desplazamiento: "scroll"
+        desplazamiento: "scroll",
+        // V3 Batch 2 aliases: i18n dictionary verb forms the es tokenizer already
+        // normalizes (probe-verified). Appended — localization canonicals unchanged.
+        cambiar: "change",
+        enfocar: "focus",
+        desenfocar: "blur",
+        cargar: "load",
+        desplazar: "scroll",
+        // V3c burn-down (2026-07-14): dictionary event words S5b never covered —
+        // parse-side registration so the i18n dict forms resolve (round-trip-tested).
+        dobleclic: "dblclick",
+        rat\u00F3nentrar: "mouseenter",
+        rat\u00F3nsalir: "mouseleave",
+        rat\u00F3nmover: "mousemove",
+        teclapresar: "keypress",
+        descargar: "unload",
+        toqueempezar: "touchstart",
+        toqueterminar: "touchend",
+        toquemover: "touchmove",
+        toquecancelar: "touchcancel"
       },
       // Turkish event names → English
       tr: {
@@ -27221,7 +28342,16 @@ var init_event_handler = __esm({
         // the `kaydır`/`kaydırma` scroll precedent) keeps the event token whole.
         boyutland\u0131rma: "resize",
         boyutland\u0131r: "resize",
-        kayd\u0131rma: "scroll"
+        kayd\u0131rma: "scroll",
+        // V3 Batch 2 aliases: i18n dictionary forms the tr tokenizer already
+        // normalizes (probe-verified; farebas/farebırak are the deliberately fused
+        // dict forms — the table's own fare_bas/fare_bırak `_` entries shatter).
+        bulan\u0131k: "blur",
+        farebas: "mousedown",
+        fareb\u0131rak: "mouseup",
+        kayd\u0131r: "scroll"
+        // V3c burn-down (2026-07-14): dictionary event words S5b never covered —
+        // parse-side registration so the i18n dict forms resolve (round-trip-tested).
       },
       // Portuguese event names → English
       pt: {
@@ -27248,7 +28378,19 @@ var init_event_handler = __esm({
         carregar: "load",
         carregamento: "load",
         rolagem: "scroll",
-        rolar: "scroll"
+        rolar: "scroll",
+        // V3c burn-down (2026-07-14): dictionary event words S5b never covered —
+        // parse-side registration so the i18n dict forms resolve (round-trip-tested).
+        duploClique: "dblclick",
+        mouseEntrar: "mouseenter",
+        mouseSair: "mouseleave",
+        mouseMover: "mousemove",
+        teclaPressionar: "keypress",
+        descarregar: "unload",
+        toqueIn\u00EDcio: "touchstart",
+        toqueFim: "touchend",
+        toqueMover: "touchmove",
+        toqueCancelar: "touchcancel"
       },
       // Chinese event names → English
       zh: {
@@ -27274,7 +28416,18 @@ var init_event_handler = __esm({
         \u6A21\u7CCA: "blur",
         \u52A0\u8F7D: "load",
         \u8F7D\u5165: "load",
-        \u6EDA\u52A8: "scroll"
+        \u6EDA\u52A8: "scroll",
+        // V3 Batch 2 alias: the i18n dictionary keydown form (captures keydown via
+        // the registered 按键 prefix; probe-verified — kept over bare 按键 to avoid
+        // colliding with the dict's keypress entry).
+        \u6309\u952E\u6309\u4E0B: "keydown",
+        // V3c burn-down (2026-07-14): dictionary event words S5b never covered —
+        // parse-side registration so the i18n dict forms resolve (round-trip-tested).
+        \u9F20\u6807\u79FB\u52A8: "mousemove",
+        \u5378\u8F7D: "unload",
+        \u8C03\u6574\u5927\u5C0F: "resize",
+        \u89E6\u6478\u5F00\u59CB: "touchstart",
+        \u89E6\u6478\u79FB\u52A8: "touchmove"
       },
       // French event names → English
       fr: {
@@ -27299,7 +28452,22 @@ var init_event_handler = __esm({
         chargement: "load",
         charger: "load",
         d\u00E9filement: "scroll",
-        d\u00E9filer: "scroll"
+        d\u00E9filer: "scroll",
+        // V3 Batch 2 alias: i18n dictionary form the fr tokenizer already
+        // normalizes (probe-verified).
+        flou: "blur",
+        // V3c burn-down (2026-07-14): dictionary event words S5b never covered —
+        // parse-side registration so the i18n dict forms resolve (round-trip-tested).
+        doubleclic: "dblclick",
+        sourisentrer: "mouseenter",
+        sourissortir: "mouseleave",
+        sourisbouger: "mousemove",
+        touchepress\u00E9e: "keypress",
+        d\u00E9charger: "unload",
+        touchercommencer: "touchstart",
+        toucherfin: "touchend",
+        toucherbouger: "touchmove",
+        toucherannuler: "touchcancel"
       },
       // German event names → English
       de: {
@@ -27323,7 +28491,26 @@ var init_event_handler = __esm({
         laden: "load",
         ladung: "load",
         scrollen: "scroll",
-        bl\u00E4ttern: "scroll"
+        bl\u00E4ttern: "scroll",
+        // V3 Batch 2 aliases: the de tokenizer's registered multi-word event forms
+        // (probe-verified; the table's older `taste runter`/`taste hoch`/`maus
+        // über`/`maus raus` entries are aspirational — they do not tokenize).
+        "taste unten": "keydown",
+        "taste oben": "keyup",
+        "maus dr\xFCber": "mouseover",
+        "maus weg": "mouseout",
+        // V3c burn-down (2026-07-14): dictionary event words S5b never covered —
+        // parse-side registration so the i18n dict forms resolve (round-trip-tested).
+        doppelklick: "dblclick",
+        mauseintreten: "mouseenter",
+        mausverlassen: "mouseleave",
+        mausbewegen: "mousemove",
+        tastedr\u00FCcken: "keypress",
+        entladen: "unload",
+        ber\u00FChrungstart: "touchstart",
+        ber\u00FChrungend: "touchend",
+        ber\u00FChrungbewegen: "touchmove",
+        ber\u00FChrungabbrechen: "touchcancel"
       },
       // Indonesian event names → English
       id: {
@@ -27343,7 +28530,18 @@ var init_event_handler = __esm({
         muat: "load",
         memuat: "load",
         gulir: "scroll",
-        menggulir: "scroll"
+        menggulir: "scroll",
+        // V3 Batch 2 aliases: tekan_tombol captures keydown via the registered
+        // `tekan`; arahkan/tinggalkan are the tokenizer's registered natives;
+        // keyup is English passthrough (no parseable id native — `lepas` is
+        // unregistered). All probe-verified.
+        tekan_tombol: "keydown",
+        keyup: "keyup",
+        arahkan: "mouseover",
+        tinggalkan: "mouseout",
+        // V3c burn-down (2026-07-14): dictionary event words S5b never covered —
+        // parse-side registration so the i18n dict forms resolve (round-trip-tested).
+        bongkar: "unload"
       },
       // Bengali event names → English
       bn: {
@@ -27356,6 +28554,8 @@ var init_event_handler = __esm({
         \u099D\u09BE\u09AA\u09B8\u09BE: "blur",
         \u09AB\u09CB\u0995\u09BE\u09B8: "focus",
         \u09AA\u09B0\u09BF\u09AC\u09B0\u09CD\u09A4\u09A8: "change"
+        // V3c burn-down (2026-07-14): dictionary event words S5b never covered —
+        // parse-side registration so the i18n dict forms resolve (round-trip-tested).
       },
       // Quechua event names → English (loanwords with native adaptations)
       qu: {
@@ -27366,8 +28566,14 @@ var init_event_handler = __esm({
         yaykuy: "input",
         tikray: "change",
         "t'ikray": "change",
+        // Batch 3 aliases (appended so first-wins localization canonicals are
+        // unchanged): the dict now renders kambiay/apaykachay — probe-verified to
+        // capture the canonical event via the tokenizer keyword table, unlike
+        // tikray (captures 'toggle') and kachay ('send' in one corpus slot).
+        kambiay: "change",
         apachiy: "submit",
         kachay: "submit",
+        apaykachay: "submit",
         "llave uray": "keydown",
         "llave hawa": "keyup",
         "q'away": "focus",
@@ -27380,6 +28586,8 @@ var init_event_handler = __esm({
         kunray: "scroll",
         muyuy: "scroll",
         hatun_kay: "resize"
+        // V3c burn-down (2026-07-14): dictionary event words S5b never covered —
+        // parse-side registration so the i18n dict forms resolve (round-trip-tested).
       },
       // Swahili event names → English
       sw: {
@@ -27401,7 +28609,31 @@ var init_event_handler = __esm({
         pakia: "load",
         kupakia: "load",
         sogeza: "scroll",
-        kusogeza: "scroll"
+        kusogeza: "scroll",
+        // V3 Batch 2 aliases: i18n dictionary forms the sw tokenizer already
+        // normalizes (probe-verified; bonyeza is corpus-hot — 106 rows), plus the
+        // tokenizer's registered `sogeza juu` for mouseover (the table's `panya
+        // juu` is mouseup's dict form and maps there).
+        bonyeza: "click",
+        ingizo: "input",
+        kitufe_shuka: "keydown",
+        kitufe_juu: "keyup",
+        panya_nje: "mouseout",
+        wasilisha: "submit",
+        "sogeza juu": "mouseover",
+        // V3c burn-down (2026-07-14): dictionary event words S5b never covered —
+        // parse-side registration so the i18n dict forms resolve (round-trip-tested).
+        shuka: "unload"
+      },
+      // Vietnamese event names → English. Minimal section: the dict renders
+      // resize as the three-word đổi kích thước; the event slot captures only
+      // đổi (tokenizer-normalized → change) and `kích thước` drops. The compound
+      // key is matched by the parser's event-compound reclaim (Arc F,
+      // offset-exact join of the captured event word + the dangling fragment).
+      vi: {
+        "\u0111\u1ED5i k\xEDch th\u01B0\u1EDBc": "resize"
+        // V3c burn-down (2026-07-14): dictionary event words S5b never covered —
+        // parse-side registration so the i18n dict forms resolve (round-trip-tested).
       }
     };
     Object.fromEntries(
@@ -27435,8 +28667,10 @@ function resolveMarkerForRole(roleSpec, profile) {
   const overrideMarker = roleSpec.markerOverride?.[profile.code];
   const defaultMarker = profile.roleMarkers[roleSpec.role];
   if (overrideMarker !== void 0) {
+    const alternatives = legacyMarkerAlternatives(roleSpec, profile.code, overrideMarker);
     return {
       primary: overrideMarker,
+      ...alternatives && { alternatives },
       position: defaultMarker?.position ?? "before",
       isOverride: true
     };
@@ -27454,6 +28688,18 @@ function resolveMarkerForRole(roleSpec, profile) {
   }
   return null;
 }
+function legacyMarkerAlternatives(roleSpec, languageCode, overrideMarker) {
+  const legacy = roleSpec.markerLegacy?.[languageCode];
+  if (!legacy?.length) return void 0;
+  const alternatives = [...new Set(legacy)].filter((a) => a && a !== overrideMarker);
+  return alternatives.length ? alternatives : void 0;
+}
+function schemaMarkerAlternatives(roleSpec, languageCode, marker) {
+  const legacy = roleSpec.markerLegacy?.[languageCode] ?? [];
+  const variants = roleSpec.methodCarrier ? [] : roleSpec.markerVariants?.[languageCode] ?? [];
+  const alternatives = [.../* @__PURE__ */ new Set([...legacy, ...variants])].filter((a) => a && a !== marker);
+  return alternatives.length ? alternatives : void 0;
+}
 var init_marker_resolution = __esm({
   "src/parser/utils/marker-resolution.ts"() {
   }
@@ -27465,20 +28711,17 @@ function resolveRoleMarker(roleSpec, profile) {
   let alternatives;
   if (roleSpec.markerOverride && roleSpec.markerOverride[profile.code] !== void 0) {
     marker = roleSpec.markerOverride[profile.code];
+    alternatives = marker ? schemaMarkerAlternatives(roleSpec, profile.code, marker) : void 0;
   } else {
     const roleMarker = profile.roleMarkers[roleSpec.role];
     if (roleMarker) {
       marker = roleMarker.primary;
-      alternatives = roleMarker.alternatives ? [...roleMarker.alternatives] : void 0;
-    }
-  }
-  const variants = roleSpec.markerVariants?.[profile.code];
-  if (variants && variants.length > 0) {
-    const merged = alternatives ? [...alternatives] : [];
-    for (const v of variants) {
-      if (v !== marker && !merged.includes(v)) merged.push(v);
+      const schemaAlts = schemaMarkerAlternatives(roleSpec, profile.code, marker) ?? [];
+      const merged = [.../* @__PURE__ */ new Set([...roleMarker.alternatives ?? [], ...schemaAlts])].filter(
+        (a) => a !== marker
+      );
+      alternatives = merged.length ? merged : void 0;
     }
-    alternatives = merged;
   }
   return { marker, alternatives };
 }
@@ -27574,7 +28817,17 @@ function generateSOVPatientFirstEventHandlerPattern(commandSchema, profile, keyw
   const verbToken = keyword.alternatives ? { type: "literal", value: keyword.primary, alternatives: keyword.alternatives } : { type: "literal", value: keyword.primary };
   tokens.push(verbToken);
   tokens.push(...eventHandlerSourceGroup(commandSchema, profile.roleMarkers.source));
-  tokens.push(...eventHandlerDestinationGroup(commandSchema, profile.roleMarkers.destination));
+  let trailingDestMarker = profile.roleMarkers.destination;
+  if (commandSchema.action === "swap" && trailingDestMarker) {
+    const withWord = commandSchema.roles.find((r) => r.role === "patient")?.markerOverride?.[profile.code];
+    if (withWord && withWord !== trailingDestMarker.primary) {
+      const existing = trailingDestMarker.alternatives ?? [];
+      if (!existing.includes(withWord)) {
+        trailingDestMarker = { ...trailingDestMarker, alternatives: [...existing, withWord] };
+      }
+    }
+  }
+  tokens.push(...eventHandlerDestinationGroup(commandSchema, trailingDestMarker));
   return {
     id: `${commandSchema.action}-event-${profile.code}-sov-patient-first`,
     language: profile.code,
@@ -27937,10 +29190,18 @@ function generateSOVTwoRoleDestFirstEventHandlerPattern(commandSchema, profile,
 var init_event_handlers_sov = __esm({
   "src/generators/event-handlers-sov.ts"() {
     init_command_schemas();
+    init_marker_resolution();
   }
 });
 
 // src/generators/event-handlers-vso.ts
+function mergeSchemaAlternatives(roleSpec, profile, roleMarker) {
+  const schemaAlts = schemaMarkerAlternatives(roleSpec, profile.code, roleMarker.primary) ?? [];
+  const merged = [.../* @__PURE__ */ new Set([...roleMarker.alternatives ?? [], ...schemaAlts])].filter(
+    (a) => a !== roleMarker.primary
+  );
+  return merged.length ? merged : void 0;
+}
 function generateVSOEventHandlerPattern(commandSchema, profile, keyword, eventMarker, config) {
   const tokens = [];
   if (eventMarker.position === "before") {
@@ -28006,6 +29267,19 @@ function generateVSOVerbFirstEventHandlerPattern(commandSchema, profile, keyword
     tokens.push(markerToken);
   }
   tokens.push({ type: "role", role: "event", optional: false });
+  if (commandSchema.action === "swap") {
+    const withWord = commandSchema.roles.find((r) => r.role === "patient")?.markerOverride?.[profile.code];
+    if (withWord) {
+      tokens.push({
+        type: "group",
+        optional: true,
+        tokens: [
+          { type: "literal", value: withWord },
+          { type: "role", role: "destination", optional: false }
+        ]
+      });
+    }
+  }
   return {
     id: `${commandSchema.action}-event-${profile.code}-vso-verb-first`,
     language: profile.code,
@@ -28040,11 +29314,12 @@ function generateVSOVerbFirstTwoRoleEventHandlerPattern(commandSchema, profile,
     let markerAlternatives;
     if (roleSpec.markerOverride && roleSpec.markerOverride[profile.code] !== void 0) {
       marker = roleSpec.markerOverride[profile.code];
+      markerAlternatives = marker ? schemaMarkerAlternatives(roleSpec, profile.code, marker) : void 0;
     } else {
       const roleMarker = profile.roleMarkers[roleSpec.role];
       if (roleMarker) {
         marker = roleMarker.primary;
-        markerAlternatives = roleMarker.alternatives;
+        markerAlternatives = mergeSchemaAlternatives(roleSpec, profile, roleMarker);
       }
     }
     if (marker) {
@@ -28097,11 +29372,12 @@ function generateVSOTwoRoleEventHandlerPattern(commandSchema, profile, keyword,
     let markerAlternatives;
     if (roleSpec.markerOverride && roleSpec.markerOverride[profile.code] !== void 0) {
       marker = roleSpec.markerOverride[profile.code];
+      markerAlternatives = marker ? schemaMarkerAlternatives(roleSpec, profile.code, marker) : void 0;
     } else {
       const roleMarker = profile.roleMarkers[roleSpec.role];
       if (roleMarker) {
         marker = roleMarker.primary;
-        markerAlternatives = roleMarker.alternatives;
+        markerAlternatives = mergeSchemaAlternatives(roleSpec, profile, roleMarker);
       }
     }
     if (marker) {
@@ -28234,6 +29510,7 @@ var init_event_handlers_vso = __esm({
   "src/generators/event-handlers-vso.ts"() {
     init_command_schemas();
     init_event_handlers_sov();
+    init_marker_resolution();
   }
 });
 function generatePattern(schema, profile, config = defaultConfig) {
@@ -28284,12 +29561,16 @@ function generateVerbFirstPattern(schema, profile, config = defaultConfig) {
   const keyword = profile.keywords[schema.action];
   if (!keyword) return null;
   const verbToken = keyword.alternatives ? { type: "literal", value: keyword.primary, alternatives: keyword.alternatives } : { type: "literal", value: keyword.primary };
-  const roleTokens = requiredRoles.map((r) => ({
-    type: "role",
-    role: r.role,
-    optional: false,
-    expectedTypes: r.expectedTypes
-  }));
+  const roleTokens = requiredRoles.flatMap((r) => {
+    const prefix = r.valuePrefixLiteral?.[profile.code];
+    const roleToken = {
+      type: "role",
+      role: r.role,
+      optional: false,
+      expectedTypes: r.expectedTypes
+    };
+    return prefix ? [{ type: "literal", value: prefix }, roleToken] : [roleToken];
+  });
   return {
     id: `${schema.action}-${profile.code}-generated-verb-first`,
     language: profile.code,
@@ -28331,6 +29612,37 @@ function generatePatternVariants(schema, profile, config = defaultConfig) {
       patterns.push(verbFirst);
     }
   }
+  for (const v of schema.rolePrefixLiteralVariants ?? []) {
+    const literal = v.literal[profile.code];
+    if (!literal) continue;
+    const { rolePrefixLiteralVariants: _omitted, ...baseSchema } = schema;
+    const cloneSchema2 = {
+      ...baseSchema,
+      roles: schema.roles.map(
+        (r) => r.role === v.role ? { ...r, valuePrefixLiteral: { [profile.code]: literal } } : r
+      )
+    };
+    const delta = v.priorityDelta ?? 5;
+    const carrier = v.methodCarrier ? { [v.methodCarrier]: { value: literal } } : {};
+    const main = generatePattern(cloneSchema2, profile, config);
+    patterns.push({
+      ...main,
+      id: `${schema.action}-${profile.code}-generated-${v.idSuffix}`,
+      priority: (config.basePriority ?? 100) + delta,
+      extraction: { ...main.extraction, ...carrier }
+    });
+    if (config.generateVerbFirstVariants !== false) {
+      const verbFirstUrl = generateVerbFirstPattern(cloneSchema2, profile, config);
+      if (verbFirstUrl) {
+        patterns.push({
+          ...verbFirstUrl,
+          id: `${schema.action}-${profile.code}-generated-verb-first-${v.idSuffix}`,
+          priority: (config.basePriority ?? 100) - 20 + delta,
+          extraction: { ...verbFirstUrl.extraction, ...carrier }
+        });
+      }
+    }
+  }
   return patterns;
 }
 function generatePatternsForLanguage(profile, config = defaultConfig) {
@@ -28554,34 +29866,53 @@ function buildRoleToken(roleSpec, profile) {
   const tokens = [];
   const overrideMarker = roleSpec.markerOverride?.[profile.code];
   const defaultMarker = profile.roleMarkers[roleSpec.role];
+  const suppressMarker = roleSpec.renderOverride?.[profile.code] === "";
   const roleValueToken = {
     type: "role",
     role: roleSpec.role,
     optional: !roleSpec.required,
     expectedTypes: roleSpec.expectedTypes
   };
+  const prefixLiteral = roleSpec.valuePrefixLiteral?.[profile.code];
+  const pushPrefixed = () => {
+    if (prefixLiteral) tokens.push({ type: "literal", value: prefixLiteral });
+    tokens.push(roleValueToken);
+  };
   if (overrideMarker !== void 0) {
     const markerWords = overrideMarker ? overrideMarker.split(/\s+/).filter(Boolean) : [];
     const position = defaultMarker?.position ?? "before";
     const optionalMarker = roleSpec.markerOptional?.[profile.code] === true;
     const pushWord = (word) => {
-      const literal = { type: "literal", value: word };
+      const alternatives = markerWords.length === 1 ? schemaMarkerAlternatives(roleSpec, profile.code, word) ?? [] : [];
+      const literal = {
+        type: "literal",
+        value: word,
+        ...alternatives.length ? { alternatives } : {},
+        ...suppressMarker ? { renderSuppress: true } : {}
+      };
       tokens.push(optionalMarker ? { type: "group", optional: true, tokens: [literal] } : literal);
     };
     if (position === "before") {
       for (const word of markerWords) pushWord(word);
-      tokens.push(roleValueToken);
+      pushPrefixed();
     } else {
-      tokens.push(roleValueToken);
+      pushPrefixed();
       for (const word of markerWords) pushWord(word);
     }
   } else if (defaultMarker) {
-    const variantAlts = roleSpec.markerVariants?.[profile.code] ?? [];
     const asMarker = () => {
       const alternatives = [
-        .../* @__PURE__ */ new Set([...defaultMarker.alternatives ?? [], ...variantAlts])
+        .../* @__PURE__ */ new Set([
+          ...defaultMarker.alternatives ?? [],
+          ...schemaMarkerAlternatives(roleSpec, profile.code, defaultMarker.primary) ?? []
+        ])
       ].filter((a) => a !== defaultMarker.primary);
-      return alternatives.length ? { type: "literal", value: defaultMarker.primary, alternatives } : { type: "literal", value: defaultMarker.primary };
+      return {
+        type: "literal",
+        value: defaultMarker.primary,
+        ...alternatives.length ? { alternatives } : {},
+        ...suppressMarker ? { renderSuppress: true } : {}
+      };
     };
     const pushMarker = (marker) => {
       tokens.push(
@@ -28592,13 +29923,13 @@ function buildRoleToken(roleSpec, profile) {
       if (defaultMarker.primary) {
         pushMarker(asMarker());
       }
-      tokens.push(roleValueToken);
+      pushPrefixed();
     } else {
-      tokens.push(roleValueToken);
+      pushPrefixed();
       pushMarker(asMarker());
     }
   } else {
-    tokens.push(roleValueToken);
+    pushPrefixed();
   }
   return tokens;
 }
@@ -28607,12 +29938,22 @@ function buildExtractionRules(schema, profile) {
   for (const roleSpec of schema.roles) {
     const overrideMarker = roleSpec.markerOverride?.[profile.code];
     const defaultMarker = profile.roleMarkers[roleSpec.role];
-    if (overrideMarker !== void 0) {
-      rules[roleSpec.role] = overrideMarker ? { marker: overrideMarker } : {};
+    if (roleSpec.valuePrefixLiteral?.[profile.code]) {
+      rules[roleSpec.role] = { marker: roleSpec.valuePrefixLiteral[profile.code] };
+    } else if (overrideMarker !== void 0) {
+      if (!overrideMarker) {
+        rules[roleSpec.role] = {};
+      } else {
+        const isSingleWord = !/\s/.test(overrideMarker.trim());
+        const markerAlternatives = isSingleWord ? schemaMarkerAlternatives(roleSpec, profile.code, overrideMarker) ?? [] : [];
+        rules[roleSpec.role] = markerAlternatives.length ? { marker: overrideMarker, markerAlternatives } : { marker: overrideMarker };
+      }
     } else if (defaultMarker && defaultMarker.primary) {
-      const variantAlts = roleSpec.markerVariants?.[profile.code] ?? [];
       const markerAlternatives = [
-        .../* @__PURE__ */ new Set([...defaultMarker.alternatives ?? [], ...variantAlts])
+        .../* @__PURE__ */ new Set([
+          ...defaultMarker.alternatives ?? [],
+          ...schemaMarkerAlternatives(roleSpec, profile.code, defaultMarker.primary) ?? []
+        ])
       ].filter((a) => a !== defaultMarker.primary);
       rules[roleSpec.role] = markerAlternatives.length ? { marker: defaultMarker.primary, markerAlternatives } : { marker: defaultMarker.primary };
     } else {
@@ -28681,6 +30022,135 @@ var init_pattern_generator = __esm({
   }
 });
 
+// src/patterns/languages/en/fetch.ts
+var fetchWithResponseTypeEnglish, fetchWithOptionsAndResponseTypeEnglish, fetchWithOptionsEnglish, fetchSimpleEnglish, fetchPatternsEn;
+var init_fetch = __esm({
+  "src/patterns/languages/en/fetch.ts"() {
+    fetchWithResponseTypeEnglish = {
+      id: "fetch-en-with-response-type",
+      language: "en",
+      command: "fetch",
+      priority: 90,
+      // Higher than simple pattern (80) to capture "as" modifier first
+      template: {
+        format: "fetch {source} as {responseType}",
+        tokens: [
+          { type: "literal", value: "fetch" },
+          { type: "role", role: "source", expectedTypes: ["literal", "expression"] },
+          { type: "literal", value: "as" },
+          // json/text/html are identifiers not keywords, so we need to accept 'expression' type
+          { type: "role", role: "responseType", expectedTypes: ["literal", "expression"] }
+        ]
+      },
+      extraction: {
+        source: { position: 1 },
+        responseType: { marker: "as" }
+      }
+    };
+    fetchWithOptionsAndResponseTypeEnglish = {
+      id: "fetch-en-with-options-as",
+      language: "en",
+      command: "fetch",
+      priority: 95,
+      template: {
+        format: "fetch {source} with {style} as {responseType}",
+        tokens: [
+          { type: "literal", value: "fetch" },
+          { type: "role", role: "source", expectedTypes: ["literal", "expression"] },
+          { type: "literal", value: "with", alternatives: ["by", "using"] },
+          // expression-ONLY: routes `{ … }` to the object-literal fold, which keeps
+          // the source text intact for the expression parser.
+          { type: "role", role: "style", expectedTypes: ["expression"] },
+          { type: "literal", value: "as" },
+          { type: "role", role: "responseType", expectedTypes: ["literal", "expression"] }
+        ]
+      },
+      extraction: {
+        source: { position: 1 },
+        style: { marker: "with" },
+        responseType: { marker: "as" }
+      }
+    };
+    fetchWithOptionsEnglish = {
+      id: "fetch-en-with-options",
+      language: "en",
+      command: "fetch",
+      priority: 93,
+      // Below the with+as pattern, above the response-type pattern (90)
+      template: {
+        format: "fetch {source} with {style}",
+        tokens: [
+          { type: "literal", value: "fetch" },
+          { type: "role", role: "source", expectedTypes: ["literal", "expression"] },
+          { type: "literal", value: "with", alternatives: ["by", "using"] },
+          { type: "role", role: "style", expectedTypes: ["expression"] }
+        ]
+      },
+      extraction: {
+        source: { position: 1 },
+        style: { marker: "with" }
+      }
+    };
+    fetchSimpleEnglish = {
+      id: "fetch-en-simple",
+      language: "en",
+      command: "fetch",
+      priority: 80,
+      // Lower than response type pattern (90) - fallback when "as" not present
+      template: {
+        format: "fetch {source}",
+        tokens: [
+          { type: "literal", value: "fetch" },
+          { type: "role", role: "source" }
+        ]
+      },
+      extraction: {
+        source: { position: 1 }
+      }
+    };
+    fetchPatternsEn = [
+      fetchWithOptionsAndResponseTypeEnglish,
+      fetchWithOptionsEnglish,
+      fetchWithResponseTypeEnglish,
+      fetchSimpleEnglish
+    ];
+  }
+});
+
+// src/patterns/languages/en/pick.ts
+var pickVariantEnglish, pickPatternsEn;
+var init_pick = __esm({
+  "src/patterns/languages/en/pick.ts"() {
+    pickVariantEnglish = {
+      id: "pick-en-variant",
+      language: "en",
+      command: "pick",
+      priority: 110,
+      template: {
+        format: "pick {method} {patient} of {source}",
+        tokens: [
+          { type: "literal", value: "pick" },
+          // Variant word: `characters`/`items`/`match` tokenize as identifiers
+          // (expression), `first`/`last`/`random` as keywords.
+          { type: "role", role: "method", expectedTypes: ["literal", "expression"] },
+          // Range/count/index. The pick-range assembler folds `<a> to <b>
+          // [inclusive|exclusive]` into one expression value here; a lone count
+          // (`3`) is captured as a single literal.
+          { type: "role", role: "patient", expectedTypes: ["literal", "expression"] },
+          { type: "literal", value: "of", alternatives: ["from"] },
+          { type: "role", role: "source", expectedTypes: ["selector", "reference", "expression"] }
+        ]
+      },
+      extraction: {
+        method: { position: 1 },
+        patient: { position: 2 },
+        source: { marker: "of", markerAlternatives: ["from"] }
+      }
+    };
+    pickPatternsEn = [pickVariantEnglish];
+  }
+});
+
 // src/patterns/toggle.ts
 function getTogglePatternsBn() {
   return [
@@ -29101,6 +30571,33 @@ function getTogglePatternsQu() {
         destination: { position: 0 },
         patient: { position: 2 }
       }
+    },
+    // Patient-first with trailing destination: .open ta qhipantin .panel man
+    // t'ikray — the i18n full verb-final order (#636 qu canonicalOrder) puts
+    // the destination AFTER the patient, but every dest-bearing variant above
+    // is destination-first, so the shape fell to the verb-anchoring fallback,
+    // which glued the positional run (destination:literal="qhipantin.panel"
+    // vs en destination:expression="next .panel") — toggle-aria-expanded,
+    // R1 deferred-tail qu tail.
+    {
+      id: "toggle-qu-patient-first-dest",
+      language: "qu",
+      command: "toggle",
+      priority: 102,
+      template: {
+        format: "{patient} ta {destination} man t'ikray",
+        tokens: [
+          { type: "role", role: "patient" },
+          { type: "literal", value: "ta" },
+          { type: "role", role: "destination" },
+          { type: "literal", value: "man", alternatives: ["pa"] },
+          { type: "literal", value: "t'ikray", alternatives: ["tikray", "kutichiy"] }
+        ]
+      },
+      extraction: {
+        patient: { position: 0 },
+        destination: { position: 2 }
+      }
     }
   ];
 }
@@ -29468,11 +30965,15 @@ function repeatForInHead(language, spec) {
     // matches the verb's normalized form
   ];
   if (spec.forWords && spec.forWords.length > 0) {
-    tokens.push({
-      type: "group",
-      optional: true,
-      tokens: spec.forWords.map((w) => ({ type: "literal", value: w }))
-    });
+    if (spec.requireForWords) {
+      for (const w of spec.forWords) tokens.push({ type: "literal", value: w });
+    } else {
+      tokens.push({
+        type: "group",
+        optional: true,
+        tokens: spec.forWords.map((w) => ({ type: "literal", value: w }))
+      });
+    }
   }
   tokens.push({ type: "role", role: "patient", expectedTypes: ["expression", "reference"] });
   for (const w of spec.inWords) tokens.push({ type: "literal", value: w });
@@ -29581,10 +31082,63 @@ function repeatUntilHeadSOV(language, spec) {
     }
   };
 }
+function repeatUntilHeadSOVVerbFinal(language, spec) {
+  return {
+    id: `repeat-${language}-until-head-verb-final`,
+    language,
+    command: "repeat",
+    priority: 111,
+    // above the post-verb variant so the correct shape wins
+    template: {
+      format: `${spec.untilWord} ${spec.eventWord} {event} ${spec.objMarker} {source} ${spec.fromWord} repeat`,
+      tokens: [
+        { type: "literal", value: spec.untilWord },
+        { type: "literal", value: spec.eventWord },
+        { type: "role", role: "event", expectedTypes: ["literal", "expression"] },
+        { type: "literal", value: spec.objMarker },
+        {
+          type: "role",
+          role: "source",
+          expectedTypes: ["selector", "reference", "expression"]
+        },
+        { type: "literal", value: spec.fromWord },
+        { type: "literal", value: "repeat" }
+      ]
+    },
+    extraction: {
+      loopType: { default: { type: "literal", value: "until-event" } }
+    }
+  };
+}
+function sovForBindingHead(language, spec) {
+  return {
+    id: `for-${language}-sov-basic`,
+    language,
+    command: "for",
+    priority: 105,
+    template: {
+      format: `{patient} ${spec.inWords.join(" ")} {source} [${spec.objMarker}] ${spec.forVerb}`,
+      tokens: [
+        { type: "role", role: "patient", expectedTypes: ["expression", "reference"] },
+        ...spec.inWords.map((w) => ({ type: "literal", value: w })),
+        { type: "role", role: "source", expectedTypes: ["selector", "expression", "reference"] },
+        {
+          type: "group",
+          optional: true,
+          tokens: [{ type: "literal", value: spec.objMarker }]
+        },
+        { type: "literal", value: spec.forVerb }
+      ]
+    },
+    extraction: {
+      patient: { position: 0 }
+    }
+  };
+}
 function getRepeatPatternsForLanguage(language) {
   return BY_LANG.get(language) ?? [];
 }
-var VERB_FIRST_REPEAT_TIMES, SOV_REPEAT_TIMES, FOR_IN_HEADS, WHILE_HEADS, VERB_FIRST_UNTIL_HEADS, repeatUntilHeadQuMidClause, SOV_UNTIL_HEADS, repeatUntilHeadQu, BY_LANG, addPattern;
+var VERB_FIRST_REPEAT_TIMES, SOV_REPEAT_TIMES, FOR_IN_HEADS, WHILE_HEADS, VERB_FIRST_UNTIL_HEADS, repeatUntilHeadQuMidClause, SOV_UNTIL_HEADS, repeatUntilHeadQu, SOV_FOR_BINDING_HEADS, BY_LANG, addPattern;
 var init_repeat = __esm({
   "src/patterns/repeat.ts"() {
     VERB_FIRST_REPEAT_TIMES = [
@@ -29599,7 +31153,7 @@ var init_repeat = __esm({
       ["ar", "\u0643\u0631\u0631", "times"],
       ["he", "\u05D7\u05D6\u05D5\u05E8", "times", "\u05D0\u05EA"],
       ["id", "ulangi", "times"],
-      ["ms", "ulang", "times"],
+      ["ms", "ulang", "kali"],
       ["sw", "rudia", "times"],
       ["th", "\u0E17\u0E33\u0E0B\u0E49\u0E33", "\u0E04\u0E23\u0E31\u0E49\u0E07"],
       ["vi", "l\u1EB7p l\u1EA1i", "l\u1EA7n"],
@@ -29615,7 +31169,7 @@ var init_repeat = __esm({
       ["qu", "times", "ta"]
     ];
     FOR_IN_HEADS = [
-      ["en", { forWords: ["for"], inWords: ["in"] }],
+      ["en", { forWords: ["for"], inWords: ["in"], requireForWords: true }],
       ["es", { forWords: ["para"], inWords: ["en"] }],
       ["pt", { forWords: ["para"], inWords: ["dentro"] }],
       ["fr", { forWords: ["pour"], inWords: ["en"] }],
@@ -29629,8 +31183,11 @@ var init_repeat = __esm({
       ["he", { forWords: ["\u05E2\u05D1\u05D5\u05E8", "\u05D0\u05EA"], inWords: ["in"] }],
       ["hi", { inWords: ["\u092E\u0947\u0902"] }],
       ["bn", { inWords: ["\u098F"] }],
-      ["ja", { inWords: ["\u306E", "\u4E2D"] }],
-      ["ko", { inWords: ["\uC548", "\uC5D0"] }],
+      // ja/ko/qu containment words tokenize WHOLE (keyword→in entries added for
+      // the focus-trap Family G operand run) — the old split forms (の+中, 안+에,
+      // uku+pi) no longer appear in the stream.
+      ["ja", { inWords: ["\u306E\u4E2D"] }],
+      ["ko", { inWords: ["\uC548\uC5D0"] }],
       ["zh", { forWords: ["\u4E3A", "\u628A"], inWords: ["\u5728"] }],
       ["tr", { inWords: ["i\xE7inde"] }],
       ["id", { forWords: ["untuk"], inWords: ["dalam"] }],
@@ -29639,7 +31196,7 @@ var init_repeat = __esm({
       ["th", { forWords: ["\u0E2A\u0E33\u0E2B\u0E23\u0E31\u0E1A"], inWords: ["\u0E43\u0E19"] }],
       ["vi", { forWords: ["v\u1EDBi m\u1ED7i"], inWords: ["trong"] }],
       ["tl", { forWords: ["para_sa"], inWords: ["sa_loob"] }],
-      ["qu", { inWords: ["uku", "pi"] }]
+      ["qu", { inWords: ["ukupi"] }]
     ];
     WHILE_HEADS = [
       ["en", { whileWord: "while" }],
@@ -29735,6 +31292,16 @@ var init_repeat = __esm({
         loopType: { default: { type: "literal", value: "until-event" } }
       }
     };
+    SOV_FOR_BINDING_HEADS = [
+      // ja/ko/qu in-words are single whole tokens now (keyword→in entries — see
+      // the FOR_IN_HEADS note); the split forms are gone from the stream.
+      ["ja", { inWords: ["\u306E\u4E2D"], objMarker: "\u3092", forVerb: "\u305F\u3081\u306B" }],
+      ["ko", { inWords: ["\uC548\uC5D0"], objMarker: "\uB97C", forVerb: "\uAC01\uAC01" }],
+      ["tr", { inWords: ["i\xE7inde"], objMarker: "i", forVerb: "i\xE7in" }],
+      ["qu", { inWords: ["ukupi"], objMarker: "ta", forVerb: "sapankaq" }],
+      ["bn", { inWords: ["\u098F"], objMarker: "\u0995\u09C7", forVerb: "\u099C\u09A8\u09CD\u09AF" }],
+      ["hi", { inWords: ["\u092E\u0947\u0902"], objMarker: "\u0915\u094B", forVerb: "\u0939\u0947\u0924\u0941" }]
+    ];
     BY_LANG = /* @__PURE__ */ new Map();
     addPattern = (lang, p) => {
       const list = BY_LANG.get(lang);
@@ -29750,6 +31317,9 @@ var init_repeat = __esm({
     for (const [lang, spec] of FOR_IN_HEADS) {
       addPattern(lang, repeatForInHead(lang, spec));
     }
+    for (const [lang, spec] of SOV_FOR_BINDING_HEADS) {
+      addPattern(lang, sovForBindingHead(lang, spec));
+    }
     for (const [lang, spec] of WHILE_HEADS) {
       addPattern(lang, repeatWhileHead(lang, spec));
     }
@@ -29758,6 +31328,9 @@ var init_repeat = __esm({
     }
     for (const [lang, spec] of SOV_UNTIL_HEADS) {
       addPattern(lang, repeatUntilHeadSOV(lang, spec));
+      if (lang === "tr") {
+        addPattern(lang, repeatUntilHeadSOVVerbFinal(lang, spec));
+      }
     }
     addPattern("qu", repeatUntilHeadQu);
     addPattern("qu", repeatUntilHeadQuMidClause);
@@ -29877,6 +31450,121 @@ function getWaitPatternsTl() {
     }
   ];
 }
+function verbFinalOrRunWait(id, language, verb, sourceMarker, orWord, parenArgCount, sourceMarkerAlternatives) {
+  const parenGroup = () => ({
+    type: "group",
+    optional: true,
+    tokens: [
+      { type: "literal", value: "(" },
+      ...Array.from({ length: parenArgCount }, (_, i) => [
+        ...i > 0 ? [{ type: "literal", value: "," }] : [],
+        {
+          type: "role",
+          role: "condition",
+          expectedTypes: ["expression", "literal", "reference"]
+        }
+      ]).flat(),
+      { type: "literal", value: ")" }
+    ]
+  });
+  return {
+    id,
+    language,
+    command: "wait",
+    priority: 105,
+    template: {
+      format: `{source} ${sourceMarker} {duration} ${orWord} {patient} ${verb}`,
+      tokens: [
+        { type: "role", role: "source", expectedTypes: ["expression", "reference"] },
+        {
+          type: "literal",
+          value: sourceMarker,
+          ...sourceMarkerAlternatives ? { alternatives: sourceMarkerAlternatives } : {}
+        },
+        { type: "role", role: "duration", expectedTypes: ["expression", "literal"] },
+        parenGroup(),
+        { type: "literal", value: orWord },
+        { type: "role", role: "patient", expectedTypes: ["expression", "literal"] },
+        parenGroup(),
+        { type: "literal", value: verb }
+      ]
+    },
+    extraction: {
+      source: { position: 0 },
+      duration: { position: 2 }
+    }
+  };
+}
+function verbFirstOrRunWait(id, language, verb, orWord, forWord, sourceMarker, parenArgCount) {
+  const parenGroup = () => ({
+    type: "group",
+    optional: true,
+    tokens: [
+      { type: "literal", value: "(" },
+      ...Array.from({ length: parenArgCount }, (_, i) => [
+        ...i > 0 ? [{ type: "literal", value: "," }] : [],
+        {
+          type: "role",
+          role: "condition",
+          expectedTypes: ["expression", "literal", "reference"]
+        }
+      ]).flat(),
+      { type: "literal", value: ")" }
+    ]
+  });
+  const forGroup = () => ({
+    type: "group",
+    optional: true,
+    tokens: [{ type: "literal", value: forWord }]
+  });
+  return {
+    id,
+    language,
+    command: "wait",
+    priority: 105,
+    template: {
+      format: `${verb} {duration} ${orWord} [${forWord}] {patient} [${forWord}] {source} ${sourceMarker}`,
+      tokens: [
+        { type: "literal", value: verb },
+        { type: "role", role: "duration", expectedTypes: ["expression", "literal"] },
+        parenGroup(),
+        { type: "literal", value: orWord },
+        forGroup(),
+        { type: "role", role: "patient", expectedTypes: ["expression", "literal"] },
+        parenGroup(),
+        forGroup(),
+        { type: "role", role: "source", expectedTypes: ["expression", "reference"] },
+        { type: "literal", value: sourceMarker }
+      ]
+    },
+    extraction: {
+      duration: { position: 1 },
+      source: { position: 8 }
+    }
+  };
+}
+function getWaitPatternsBn() {
+  return [
+    verbFirstOrRunWait("wait-bn-or-run", "bn", "\u0985\u09AA\u09C7\u0995\u09CD\u09B7\u09BE", "\u0985\u09A5\u09AC\u09BE", "\u099C\u09A8\u09CD\u09AF", "\u09A5\u09C7\u0995\u09C7", 1),
+    verbFirstOrRunWait("wait-bn-or-run-2arg", "bn", "\u0985\u09AA\u09C7\u0995\u09CD\u09B7\u09BE", "\u0985\u09A5\u09AC\u09BE", "\u099C\u09A8\u09CD\u09AF", "\u09A5\u09C7\u0995\u09C7", 2)
+  ];
+}
+function getWaitPatternsTr() {
+  return [
+    verbFinalOrRunWait("wait-tr-or-run", "tr", "bekle", "den", "veya", 1, ["dan", "ten", "tan"]),
+    verbFinalOrRunWait("wait-tr-or-run-2arg", "tr", "bekle", "den", "veya", 2, [
+      "dan",
+      "ten",
+      "tan"
+    ])
+  ];
+}
+function getWaitPatternsQu() {
+  return [
+    verbFinalOrRunWait("wait-qu-or-run", "qu", "suyay", "manta", "utaq", 1),
+    verbFinalOrRunWait("wait-qu-or-run-2arg", "qu", "suyay", "manta", "utaq", 2)
+  ];
+}
 function getWaitPatternsForLanguage(language) {
   switch (language) {
     case "en":
@@ -29887,8 +31575,14 @@ function getWaitPatternsForLanguage(language) {
       return getWaitPatternsHe();
     case "ar":
       return getWaitPatternsAr();
+    case "bn":
+      return getWaitPatternsBn();
     case "tl":
       return getWaitPatternsTl();
+    case "tr":
+      return getWaitPatternsTr();
+    case "qu":
+      return getWaitPatternsQu();
     default:
       return [];
   }
@@ -29911,8 +31605,8 @@ function buildEnglishPatterns() {
   patterns.push(...getRepeatPatternsForLanguage("en"));
   patterns.push(...getWaitPatternsForLanguage("en"));
   patterns.push(
-    fetchWithResponseTypeEnglish,
-    fetchSimpleEnglish,
+    ...fetchPatternsEn,
+    ...pickPatternsEn,
     swapElementEnglish,
     swapSimpleEnglish,
     repeatUntilEventFromEnglish,
@@ -29930,51 +31624,18 @@ function buildEnglishPatterns() {
   patterns.push(...generatedPatterns);
   return patterns;
 }
-var fetchWithResponseTypeEnglish, fetchSimpleEnglish, swapSimpleEnglish, swapElementEnglish, repeatUntilEventFromEnglish, repeatUntilEventEnglish, repeatTimesEnglish, repeatForeverEnglish, setPossessiveEnglish, forEnglish, ifEnglish, unlessEnglish, temporalInEnglish, temporalAfterEnglish;
+var swapSimpleEnglish, swapElementEnglish, repeatUntilEventFromEnglish, repeatUntilEventEnglish, repeatTimesEnglish, repeatForeverEnglish, setPossessiveEnglish, forEnglish, ifEnglish, unlessEnglish, temporalInEnglish, temporalAfterEnglish;
 var init_en = __esm({
   "src/patterns/en.ts"() {
     init_english();
     init_pattern_generator();
+    init_fetch();
+    init_pick();
     init_toggle();
     init_put();
     init_event_handler();
     init_repeat();
     init_wait();
-    fetchWithResponseTypeEnglish = {
-      id: "fetch-en-with-response-type",
-      language: "en",
-      command: "fetch",
-      priority: 90,
-      template: {
-        format: "fetch {source} as {responseType}",
-        tokens: [
-          { type: "literal", value: "fetch" },
-          { type: "role", role: "source", expectedTypes: ["literal", "expression"] },
-          { type: "literal", value: "as" },
-          { type: "role", role: "responseType", expectedTypes: ["literal", "expression"] }
-        ]
-      },
-      extraction: {
-        source: { position: 1 },
-        responseType: { marker: "as" }
-      }
-    };
-    fetchSimpleEnglish = {
-      id: "fetch-en-simple",
-      language: "en",
-      command: "fetch",
-      priority: 80,
-      template: {
-        format: "fetch {source}",
-        tokens: [
-          { type: "literal", value: "fetch" },
-          { type: "role", role: "source" }
-        ]
-      },
-      extraction: {
-        source: { position: 1 }
-      }
-    };
     swapSimpleEnglish = {
       id: "swap-en-handcrafted",
       language: "en",
@@ -30246,6 +31907,15 @@ init_chinese();
 // src/parser/pattern-matcher.ts
 init_command_schemas();
 
+// src/parser/utils/possessive-keywords.ts
+init_english();
+
+// src/parser/utils/expression-lexicon.ts
+init_command_schemas();
+new Set(
+  Object.keys(commandSchemas).map((a) => a.toLowerCase())
+);
+
 // src/parser/pattern-matcher.ts
 init_registry();
 init_put();
@@ -30254,15 +31924,6 @@ init_put();
 new Set(
   Object.values(commandSchemas).filter((s) => s.bareKeyword === true).map((s) => s.action)
 );
-/**
- * Normalized command-action keywords (the schema registry's action names).
- * Tokenizers normalize every language's command verbs to these forms, so the
- * set is language-independent. Used to keep the positional source clause
- * from consuming a following command's verb as a locative marker.
- */
-new Set(
-  Object.keys(commandSchemas).map((a) => a.toLowerCase())
-);
 
 // src/tokenizers/index.ts
 init_registry();
@@ -30298,6 +31959,9 @@ init_command_schemas();
 // src/utils/confidence-calculator.ts
 init_registry();
 
+// src/explicit/converter.ts
+init_registry();
+
 // src/cache/semantic-cache.ts
 var SemanticCache = class {
   constructor(config = {}) {
@@ -30621,6 +32285,231 @@ init_wait();
 // src/patterns/builders.ts
 init_repeat();
 
+// src/patterns/languages/en/index.ts
+init_fetch();
+
+// src/patterns/languages/en/swap.ts
+var swapSimpleEnglish2 = {
+  id: "swap-en-handcrafted",
+  language: "en",
+  command: "swap",
+  priority: 110,
+  // Higher than generated patterns
+  template: {
+    format: "swap {method} {destination}",
+    tokens: [
+      { type: "literal", value: "swap" },
+      { type: "role", role: "method" },
+      { type: "role", role: "destination" }
+    ]
+  },
+  extraction: {
+    method: { position: 1 },
+    destination: { position: 2 }
+  }
+};
+var swapElementEnglish2 = {
+  id: "swap-en-element",
+  language: "en",
+  command: "swap",
+  priority: 120,
+  template: {
+    format: "swap {destination} with {patient}",
+    tokens: [
+      { type: "literal", value: "swap" },
+      { type: "role", role: "destination" },
+      { type: "literal", value: "with" },
+      { type: "role", role: "patient" }
+    ]
+  },
+  extraction: {}
+};
+var swapPatternsEn = [swapElementEnglish2, swapSimpleEnglish2];
+
+// src/patterns/languages/en/repeat.ts
+var repeatUntilEventFromEnglish2 = {
+  id: "repeat-en-until-event-from",
+  language: "en",
+  command: "repeat",
+  priority: 120,
+  // Highest priority - most specific pattern
+  template: {
+    format: "repeat until event {event} from {source}",
+    tokens: [
+      { type: "literal", value: "repeat" },
+      { type: "literal", value: "until" },
+      { type: "literal", value: "event" },
+      { type: "role", role: "event", expectedTypes: ["literal", "expression"] },
+      { type: "literal", value: "from" },
+      { type: "role", role: "source", expectedTypes: ["selector", "reference", "expression"] }
+    ]
+  },
+  extraction: {
+    event: { marker: "event" },
+    source: { marker: "from" },
+    loopType: { default: { type: "literal", value: "until-event" } }
+  }
+};
+var repeatUntilEventEnglish2 = {
+  id: "repeat-en-until-event",
+  language: "en",
+  command: "repeat",
+  priority: 110,
+  // Lower than "from" variant, but higher than quantity-based repeat
+  template: {
+    format: "repeat until event {event}",
+    tokens: [
+      { type: "literal", value: "repeat" },
+      { type: "literal", value: "until" },
+      { type: "literal", value: "event" },
+      { type: "role", role: "event", expectedTypes: ["literal", "expression"] }
+    ]
+  },
+  extraction: {
+    event: { marker: "event" },
+    loopType: { default: { type: "literal", value: "until-event" } }
+  }
+};
+var repeatPatternsEn = [
+  repeatUntilEventFromEnglish2,
+  repeatUntilEventEnglish2
+];
+
+// src/patterns/languages/en/set.ts
+var setPossessiveEnglish2 = {
+  id: "set-en-possessive",
+  language: "en",
+  command: "set",
+  priority: 100,
+  // Higher than generated setSchema (80)
+  template: {
+    format: "set {destination} to {patient}",
+    tokens: [
+      { type: "literal", value: "set" },
+      // Role token with property-path support for possessive syntax
+      {
+        type: "role",
+        role: "destination",
+        expectedTypes: ["property-path", "selector", "reference", "expression"]
+      },
+      { type: "literal", value: "to" },
+      { type: "role", role: "patient", expectedTypes: ["literal", "expression", "reference"] }
+    ]
+  },
+  extraction: {
+    destination: { position: 1 },
+    patient: { marker: "to" }
+  }
+};
+var setPatternsEn = [setPossessiveEnglish2];
+
+// src/patterns/languages/en/control-flow.ts
+var forEnglish2 = {
+  id: "for-en-basic",
+  language: "en",
+  command: "for",
+  priority: 100,
+  template: {
+    format: "for {patient} in {source}",
+    tokens: [
+      { type: "literal", value: "for" },
+      { type: "role", role: "patient", expectedTypes: ["expression", "reference"] },
+      // Loop variable
+      { type: "literal", value: "in" },
+      { type: "role", role: "source", expectedTypes: ["selector", "expression", "reference"] }
+      // Collection
+    ]
+  },
+  extraction: {
+    patient: { position: 1 },
+    source: { marker: "in" }
+    // NOTE: no `loopType` default — see the rationale in patterns/en.ts
+    // `forEnglish` (the `for` schema has no loopType role; a `loopType:literal="for"`
+    // here only duplicates the action name and is the R1 outlier no translation
+    // reproduces). R2-safe (forMapper reads only patient+source). Kept in sync.
+  }
+};
+var ifEnglish2 = {
+  id: "if-en-basic",
+  language: "en",
+  command: "if",
+  priority: 100,
+  template: {
+    format: "if {condition}",
+    tokens: [
+      { type: "literal", value: "if" },
+      { type: "role", role: "condition", expectedTypes: ["expression", "reference", "selector"] }
+    ]
+  },
+  extraction: {
+    condition: { position: 1 }
+  }
+};
+var unlessEnglish2 = {
+  id: "unless-en-basic",
+  language: "en",
+  command: "unless",
+  priority: 100,
+  template: {
+    format: "unless {condition}",
+    tokens: [
+      { type: "literal", value: "unless" },
+      { type: "role", role: "condition", expectedTypes: ["expression", "reference", "selector"] }
+    ]
+  },
+  extraction: {
+    condition: { position: 1 }
+  }
+};
+var controlFlowPatternsEn = [forEnglish2, ifEnglish2, unlessEnglish2];
+
+// src/patterns/languages/en/temporal.ts
+var temporalInEnglish2 = {
+  id: "temporal-en-in",
+  language: "en",
+  command: "wait",
+  priority: 95,
+  // Lower than standard wait patterns
+  template: {
+    format: "in {duration}",
+    tokens: [
+      { type: "literal", value: "in" },
+      { type: "role", role: "duration", expectedTypes: ["literal", "expression"] }
+    ]
+  },
+  extraction: {
+    duration: { position: 1 }
+  }
+};
+var temporalAfterEnglish2 = {
+  id: "temporal-en-after",
+  language: "en",
+  command: "wait",
+  priority: 95,
+  // Lower than standard wait patterns
+  template: {
+    format: "after {duration}",
+    tokens: [
+      { type: "literal", value: "after" },
+      { type: "role", role: "duration", expectedTypes: ["literal", "expression"] }
+    ]
+  },
+  extraction: {
+    duration: { position: 1 }
+  }
+};
+var temporalPatternsEn = [temporalInEnglish2, temporalAfterEnglish2];
+
+// src/patterns/languages/en/index.ts
+[
+  ...fetchPatternsEn,
+  ...swapPatternsEn,
+  ...repeatPatternsEn,
+  ...setPatternsEn,
+  ...controlFlowPatternsEn,
+  ...temporalPatternsEn
+];
+
 // src/patterns/builders.ts
 init_pattern_generator();
 init_registry();
@@ -31025,6 +32914,81 @@ function inferRoles(name, args, modifiers, target) {
             }
             break;
         }
+        case 'go': {
+            const kw = (n) => {
+                if (!n || typeof n !== 'object')
+                    return undefined;
+                const v = n;
+                if (v.type === 'identifier') {
+                    if (typeof v.name === 'string' && v.name !== '')
+                        return v.name;
+                    return typeof v.value === 'string' ? v.value : undefined;
+                }
+                if (v.type === 'literal' && typeof v.value === 'string')
+                    return v.value;
+                return undefined;
+            };
+            const asNode = (x) => x && typeof x === 'object' && 'type' in x ? x : undefined;
+            let destination;
+            let method;
+            const onMod = asNode(modifiers?.on);
+            if (args.length === 0 && onMod) {
+                destination = onMod;
+                if (kw(asNode(modifiers?.method)) === 'url') {
+                    method = { type: 'literal', value: 'url' };
+                }
+            }
+            else {
+                const words = args.map(kw);
+                const urlIdx = words.indexOf('url');
+                if (urlIdx !== -1 && args[urlIdx + 1]) {
+                    destination = args[urlIdx + 1];
+                    method = { type: 'literal', value: 'url' };
+                }
+                else {
+                    const SKIP = new Set(['to', 'the']);
+                    const POSITION = new Set([
+                        'top',
+                        'middle',
+                        'bottom',
+                        'left',
+                        'center',
+                        'right',
+                        'smoothly',
+                        'instantly',
+                        'in',
+                        'new',
+                        'window',
+                    ]);
+                    const headIdx = args.findIndex((_, i) => {
+                        const w = words[i];
+                        return w === undefined || !SKIP.has(w);
+                    });
+                    const headWord = headIdx !== -1 ? words[headIdx] : undefined;
+                    const ofIdx = words.indexOf('of');
+                    if (headWord === 'back' || headWord === 'forward') {
+                        destination = { type: 'identifier', value: headWord, name: headWord };
+                    }
+                    else if (ofIdx !== -1 && args[ofIdx + 1]) {
+                        destination = kw(args[ofIdx + 1]) === 'the' ? args[ofIdx + 2] : args[ofIdx + 1];
+                    }
+                    else if (headIdx !== -1 && !POSITION.has(headWord ?? '')) {
+                        destination = args[headIdx];
+                    }
+                }
+            }
+            const destWord = kw(destination);
+            if ((destWord === 'back' || destWord === 'forward') && destination?.type !== 'identifier') {
+                destination = { type: 'identifier', value: destWord, name: destWord };
+            }
+            if (!destination && target)
+                destination = target;
+            if (destination)
+                roles.destination = destination;
+            if (method)
+                roles.method = method;
+            break;
+        }
         default: {
             const schema = getSchema(name);
             if (!schema)