@lokascript/i18n 2.5.1 → 2.7.0

package/dist/lokascript-i18n.mjs

@@ -17,6 +17,49 @@ const ENGLISH_MODIFIER_ROLES = {
     over: 'duration',
     for: 'duration',
 };
+/**
+ * Maps a command verb to its **primary** semantic role — the role of the
+ * command's first/leading argument when no explicit modifier keyword marks it.
+ *
+ * The generic argument parser in the transformer defaults the first unmarked
+ * argument to `patient`, which is correct for the majority of commands
+ * (`toggle .x`, `add .x`, …) but wrong for commands whose leading argument is a
+ * non-patient — e.g. `wait <duration>`. Marking a duration as a patient emits a
+ * spurious object-marker in the target language (Chinese `等待 把 1s`, ungrammatical;
+ * Japanese `1s を 待つ`; Korean `1s 를 대기`), which the semantic parser then fails to
+ * match — dropping the command.
+ *
+ * Only commands whose primary role is **not** `patient` are listed here (the
+ * `patient` default already covers the rest). Mirrors the `primaryRole` field of
+ * the semantic package's command schemas (`@lokascript/semantic`); kept in sync by
+ * `schema-alignment.test.ts` so this local copy can't drift without the bundle
+ * having to pull in the whole semantic graph.
+ *
+ * @see packages/i18n/src/schema-alignment.test.ts
+ * @see docs-internal/ZH_BLOCK_BODY_SCOPE.md (#1 — transformer role model)
+ */
+const COMMAND_PRIMARY_ROLES = {
+    set: 'destination',
+    on: 'event',
+    trigger: 'event',
+    send: 'event',
+    wait: 'duration',
+    fetch: 'source',
+    get: 'source',
+    if: 'condition',
+    unless: 'condition',
+    while: 'condition',
+    repeat: 'loopType',
+    go: 'destination',
+    scroll: 'destination',
+    tell: 'destination',
+    default: 'destination',
+    swap: 'destination',
+    // morph deliberately absent: its schema primaryRole is `patient` (the
+    // element being morphed — aligned with the transformer's patient marking
+    // in the session-9 role-layout swap), and patient is the default.
+    bind: 'destination',
+};
 /**
  * English modifier keywords (derived from ENGLISH_MODIFIER_ROLES)
  */
@@ -96,6 +139,13 @@ const ENGLISH_COMMANDS = new Set([
     'trigger',
     'unless',
     'wait',
+    // v2.x reactive + realtime + service-worker DSL commands
+    'live',
+    'bind',
+    'eventsource',
+    'socket',
+    'worker',
+    'intercept',
 ]);
 // =============================================================================
 // English Keywords (Non-Commands)
@@ -622,7 +672,7 @@ const es$1 = {
         swap: 'intercambiar',
         morph: 'transformar',
         settle: 'estabilizar',
-        append: 'añadir',
+        append: 'anexar', // profile primary; 'añadir' is add's word (parsed as add)
         exit: 'salir',
         install: 'instalar',
         breakpoint: 'punto-interrupción',
@@ -755,7 +805,7 @@ const es$1 = {
         prev: 'ant',
         at: 'en',
         random: 'aleatorio',
-        closest: 'máscercano',
+        closest: 'cercano',
         parent: 'padre',
         children: 'hijos',
         within: 'dentro',
@@ -814,7 +864,7 @@ const ja$1 = {
         hide: '隠す',
         show: '表示',
         if: 'もし',
-        unless: 'でなければ',
+        unless: 'ない限り', // not でなければ — leading で particle shatters the marker
         repeat: '繰り返し',
         for: 'ために',
         while: 'の間',
@@ -823,7 +873,7 @@ const ja$1 = {
         break: '中断',
         halt: '停止',
         wait: '待つ',
-        fetch: '取得',
+        fetch: 'フェッチ',
         call: '呼び出し',
         return: '戻る',
         make: '作る',
@@ -848,7 +898,11 @@ const ja$1 = {
         morph: '変形',
         settle: '安定',
         append: '末尾追加',
-        exit: '終了',
+        // 終了 → 退出: realigned to the semantic profile primary (ja.ts `exit: 退出`).
+        // 終了 was the historic exit/end collision word (see isEndKeyword's ja note);
+        // rendered as 終了 it tokenized as a plain identifier, so a guard-clause
+        // `exit` inside `if … end` never parsed (behavior-sortable ja).
+        exit: '退出',
         install: 'インストール',
         breakpoint: 'ブレークポイント',
         clear: 'クリア',
@@ -857,6 +911,7 @@ const ja$1 = {
         select: '選択',
         clone: '複製',
         prepend: '先頭追加',
+        socket: 'ソケット',
     },
     modifiers: {
         to: 'に',
@@ -905,7 +960,7 @@ const ja$1 = {
         touchcancel: 'タッチキャンセル',
     },
     logical: {
-        when: 'とき',
+        when: '時',
         where: 'どこ',
         and: 'そして',
         or: 'または',
@@ -923,6 +978,7 @@ const ja$1 = {
         otherwise: 'そうでなければ',
         end: '終わり',
         live: 'ライブ',
+        bind: 'バインド',
         changes: '変わったら',
     },
     temporal: {
@@ -1041,6 +1097,9 @@ const fr$1 = {
         add: 'ajouter',
         remove: 'supprimer',
         toggle: 'basculer',
+        // command blur (the events section has the blur EVENT word; without this
+        // entry the transformer fell back to it and no profile read it as the verb)
+        blur: 'défocaliser',
         hide: 'cacher',
         show: 'montrer',
         if: 'si',
@@ -1077,7 +1136,7 @@ const fr$1 = {
         swap: 'échanger',
         morph: 'transformer',
         settle: 'stabiliser',
-        append: 'ajouter',
+        append: 'annexer', // profile primary; 'ajouter' is add's word (parsed as add)
         exit: 'sortir',
         install: 'installer',
         breakpoint: 'point-arrêt',
@@ -1087,6 +1146,7 @@ const fr$1 = {
         select: 'sélectionner',
         clone: 'cloner',
         prepend: 'préfixer',
+        focus: 'focaliser',
     },
     modifiers: {
         to: 'à',
@@ -1210,7 +1270,7 @@ const fr$1 = {
         prev: 'préc',
         at: 'à',
         random: 'aléatoire',
-        closest: 'plusproche',
+        closest: 'proche',
         parent: 'parent',
         children: 'enfants',
         within: 'dans',
@@ -1266,9 +1326,17 @@ const de$1 = {
         add: 'hinzufügen',
         remove: 'entfernen',
         toggle: 'umschalten',
+        // command blur (the events section has the blur EVENT word; without this
+        // entry the transformer fell back to it and no profile read it as the verb)
+        blur: 'defokussieren',
         hide: 'verstecken',
         show: 'zeigen',
-        if: 'wenn',
+        // Align with the semantic German profile's `if` primary (`falls`). The previous
+        // `wenn` collides with the profile's `when` keyword (German `wenn` = both
+        // "if" and "when"), so a transformed `if` resolved to `when` and the conditional
+        // wrapper never formed (`if`/`put` dropped). Same dict↔profile alignment as id
+        // `toggle` / get-value. `when` is unaffected (separate dict entry).
+        if: 'falls',
         unless: 'wennnicht',
         repeat: 'wiederholen',
         for: 'für',
@@ -1278,7 +1346,7 @@ const de$1 = {
         break: 'unterbrechen',
         halt: 'anhalten',
         wait: 'warten',
-        fetch: 'holen',
+        fetch: 'abrufen',
         call: 'aufrufen',
         return: 'zurückgeben',
         make: 'erstellen',
@@ -1306,12 +1374,13 @@ const de$1 = {
         exit: 'beenden',
         install: 'installieren',
         breakpoint: 'haltepunkt',
-        clear: 'löschen',
+        clear: 'bereinigen', // löschen is a remove alternative in the profile
         close: 'schließen',
         open: 'öffnen',
         select: 'auswählen',
         clone: 'klonen',
         prepend: 'voranstellen',
+        focus: 'fokussieren',
     },
     modifiers: {
         to: 'zu',
@@ -1435,7 +1504,13 @@ const de$1 = {
         prev: 'vorh',
         at: 'bei',
         random: 'zufällig',
-        closest: 'nächste',
+        // `nächste` already serves `next` (line above). German `nächste` is
+        // genuinely ambiguous (next/nearest), so emitting it for `closest` too
+        // collided: the semantic tokenizer normalizes `nächste`→next (a deliberate
+        // last-wins choice — see german.ts), and a closest reading is impossible to
+        // recover. Use the unambiguous `nächstgelegene` ("nearest-located") for
+        // closest so the two readings stay distinct end-to-end.
+        closest: 'nächstgelegene',
         parent: 'elternteil',
         children: 'kinder',
         within: 'innerhalb',
@@ -1499,7 +1574,10 @@ const ar$1 = {
         hide: 'اخف',
         show: 'اظهر',
         if: 'إذا',
-        unless: 'إلا إذا',
+        // Single-token form: the semantic ar tokenizer splits the two-word `إلا إذا`
+        // into `إلا` + `إذا`(if), which derails the `unless` block. `إلا` alone is the
+        // conventional Arabic shorthand and matches the ar profile's unless keyword.
+        unless: 'إلا',
         repeat: 'كرر',
         for: 'لكل',
         while: 'بينما',
@@ -1529,19 +1607,20 @@ const ar$1 = {
         js: 'جافاسكربت',
         async: 'متزامن',
         render: 'ارسم',
-        swap: 'بدّل',
+        swap: 'استبدل', // profile primary; 'بدّل' is toggle's word (parsed as toggle)
         morph: 'حوّل',
         settle: 'استقر',
         append: 'ألحق',
         exit: 'اخرج',
         install: 'ثبّت',
         breakpoint: 'نقطة-توقف',
-        clear: 'امسح',
+        clear: 'نظّف', // امسح is a remove alternative in the profile
         close: 'أغلق',
         open: 'افتح',
         select: 'اختر',
         clone: 'استنسخ',
         prepend: 'سبق',
+        socket: 'مقبس',
     },
     modifiers: {
         to: 'إلى',
@@ -1608,6 +1687,7 @@ const ar$1 = {
         otherwise: 'خلاف ذلك',
         end: 'النهاية',
         live: 'حي',
+        bind: 'اربط',
         changes: 'يتغير',
     },
     temporal: {
@@ -1733,9 +1813,9 @@ const ko$1 = {
         hide: '숨기다',
         show: '보이다',
         if: '만약',
-        unless: '아니면',
+        unless: '아니라면', // distinct from else `아니면` (line ~131) — was a homonym
         repeat: '반복',
-        for: '동안',
+        for: '각각', // profile's for word — 동안 is while (collision)
         while: '동안',
         until: '까지',
         continue: '계속',
@@ -1766,8 +1846,11 @@ const ko$1 = {
         swap: '교환',
         morph: '변형',
         settle: '안정',
-        append: '추가',
-        exit: '종료',
+        append: '덧붙이다', // profile primary; '추가' is add's word (parsed as add)
+        // 종료 → 나가기: realigned to the semantic profile primary (ko.ts `exit: 나가기`,
+        // whose comment already flags the 종료 end-collision). Rendered as 종료 it
+        // tokenized as a plain identifier, so a guard-clause `exit` never parsed.
+        exit: '나가기',
         install: '설치',
         breakpoint: '중단점',
         clear: '지우기',
@@ -1776,6 +1859,7 @@ const ko$1 = {
         select: '선택',
         clone: '복제',
         prepend: '앞에추가',
+        socket: '소켓',
     },
     modifiers: {
         to: '에',
@@ -1842,6 +1926,7 @@ const ko$1 = {
         otherwise: '그렇지않으면',
         end: '끝',
         live: '라이브',
+        bind: '바인드',
         changes: '변경되면',
     },
     temporal: {
@@ -1954,7 +2039,11 @@ const zh$1 = {
         tell: '告诉',
         trigger: '触发',
         send: '发送',
-        take: '获取',
+        // `拿取` (the semantic zh profile's take primary), not `获取` — `获取` is the
+        // profile's GET primary, so emitting it for take made `take …` parse as get
+        // (take-class-from-siblings: phantom get, take dropped). Exposed by the get-zh-ba
+        // pattern; same dict↔profile homonym family as pl get/fetch.
+        take: '拿取',
         put: '放置',
         set: '设置',
         get: '获得',
@@ -1973,7 +2062,10 @@ const zh$1 = {
         break: '中断',
         halt: '停止',
         wait: '等待',
-        fetch: '获取',
+        // 抓取 (zhuāqǔ, "grab/scrape") is the semantic zh profile's `fetch` primary;
+        // 获取 (huòqǔ) is its `get` primary, so emitting 获取 here made the semantic
+        // parser read a transformed `fetch` as `get`. See ZH_BLOCK_BODY_SCOPE.md #3.
+        fetch: '抓取',
         call: '调用',
         return: '返回',
         make: '制作',
@@ -2073,6 +2165,7 @@ const zh$1 = {
         otherwise: '要不然',
         end: '结束',
         live: '实时',
+        bind: '绑定',
         changes: '改变时',
     },
     temporal: {
@@ -2186,7 +2279,7 @@ const tr$1 = {
         tell: 'söyle',
         trigger: 'tetikle',
         send: 'gönder',
-        take: 'al',
+        take: 'tut', // auditor: dict emitted a word the profile reads differently
         put: 'koy',
         set: 'ayarla',
         get: 'al',
@@ -2199,7 +2292,11 @@ const tr$1 = {
         unless: 'değilse',
         repeat: 'tekrarla',
         for: 'için',
-        while: 'iken',
+        // `süresince` (the semantic tr profile's while primary), not `iken`: `iken`
+        // is the profile's WHEN primary (logical.when below also emits it), so a
+        // fronted repeat-while head tokenized as `when` and the condition dropped
+        // wholesale. Same dict↔profile homonym disambiguation as pl get/pobierz.
+        while: 'süresince',
         until: 'kadar',
         continue: 'devam',
         break: 'dur',
@@ -2229,7 +2326,7 @@ const tr$1 = {
         swap: 'takas',
         morph: 'dönüştür',
         settle: 'sabitlen',
-        append: 'ekle',
+        append: 'iliştir', // profile primary; 'ekle' is add's word (parsed as add)
         exit: 'çık',
         install: 'kur',
         breakpoint: 'kesme-noktası',
@@ -2239,6 +2336,7 @@ const tr$1 = {
         select: 'seç',
         clone: 'klonla',
         prepend: 'başınaekle',
+        socket: 'soket',
     },
     modifiers: {
         to: 'e',
@@ -2261,8 +2359,11 @@ const tr$1 = {
     events: {
         click: 'tıklama',
         dblclick: 'çift_tıklama',
-        mousedown: 'fare_bas',
-        mouseup: 'fare_bırak',
+        // Fused (no `_`): the semantic tokenizer splits on `_`, breaking event
+        // recognition (mousedown → "bas" / mouseup mis-captured). Mirrors the #535
+        // ru/uk fuse + #510 resize fix.
+        mousedown: 'farebas',
+        mouseup: 'farebırak',
         mouseenter: 'fare_gir',
         mouseleave: 'fare_çık',
         mouseover: 'fare_üstü',
@@ -2279,7 +2380,7 @@ const tr$1 = {
         reset: 'sıfırla',
         load: 'yükle',
         unload: 'yükle_kaldır',
-        resize: 'boyut_değiştir',
+        resize: 'boyutlandırma',
         scroll: 'kaydır',
         touchstart: 'dokunma_başla',
         touchend: 'dokunma_bitir',
@@ -2300,7 +2401,7 @@ const tr$1 = {
         equals: 'eşittir',
         has: 'var',
         have: 'var',
-        then: 'sonra',
+        then: 'ardından',
         else: 'yoksa',
         otherwise: 'aksi_halde',
         end: 'son',
@@ -2356,13 +2457,18 @@ const tr$1 = {
     },
     expressions: {
         first: 'ilk',
-        last: 'son',
+        // 'son' is also the END keyword emission (block terminator), and the
+        // parser's end-recognizers match it by value — so a positional `last`
+        // emission of 'son' terminated the enclosing block mid-condition
+        // (focus-trap's `eşleşir son <button/>` dropped the branch body; the sw
+        // mwisho class). 'sonuncu' ("the last one") is unambiguous.
+        last: 'sonuncu',
         next: 'sonraki',
         previous: 'önceki',
         prev: 'önc',
         at: 'de',
         random: 'rastgele',
-        closest: 'en_yakın',
+        closest: 'enyakın',
         parent: 'ebeveyn',
         children: 'çocuklar',
         within: 'içinde',
@@ -2424,7 +2530,7 @@ const id$1 = {
         get: 'dapatkan',
         add: 'tambah',
         remove: 'hapus',
-        toggle: 'ganti',
+        toggle: 'alihkan',
         hide: 'sembunyikan',
         show: 'tampilkan',
         if: 'jika',
@@ -2437,7 +2543,10 @@ const id$1 = {
         break: 'hentikan',
         halt: 'berhenti',
         wait: 'tunggu',
-        fetch: 'ambil',
+        // profile primary; 'ambil' is take's word — emitting it for fetch made every
+        // fetch parse as take once the fused take-event pattern came alive (the de
+        // holen/abrufen bug class)
+        fetch: 'muat',
         call: 'panggil',
         return: 'kembali',
         make: 'buat',
@@ -2446,7 +2555,11 @@ const id$1 = {
         catch: 'tangkap',
         measure: 'ukur',
         transition: 'transisi',
-        increment: 'tambahkan',
+        // naikkan (raise), not tambahkan — tambahkan is the semantic profile's
+        // `add` alternative, so emitting it made increment-counter parse as ADD
+        // (the #373 collision family). naikkan is the profile's increment
+        // alternative, pairing naturally with the decrement side.
+        increment: 'naikkan',
         decrement: 'kurangi',
         default: 'bawaan',
         go: 'pergi',
@@ -2457,15 +2570,15 @@ const id$1 = {
         beep: 'bunyi',
         js: 'js',
         async: 'asinkron',
-        render: 'tampilkan',
+        render: 'olah', // auditor: dict emitted a word the profile reads differently
         swap: 'tukar',
-        morph: 'ubah_bentuk',
-        settle: 'stabil',
-        append: 'tambah_akhir',
+        morph: 'ubah', // auditor: dict emitted a word the profile reads differently
+        settle: 'stabilkan', // auditor: dict emitted a word the profile reads differently
+        append: 'sisipkan', // profile primary; 'tambah_akhir' splits and is unrecognized
         exit: 'keluar',
         install: 'pasang',
         breakpoint: 'titik-henti',
-        clear: 'hapus',
+        clear: 'bersihkan', // hapus is the remove PRIMARY in the profile
         close: 'tutup',
         open: 'buka',
         select: 'pilih',
@@ -2646,20 +2759,31 @@ const qu$1 = {
         tell: 'niy',
         trigger: 'kichay',
         send: 'kachay',
-        take: 'hurquy',
+        take: 'hapiy', // auditor: dict emitted a word the profile reads differently
         put: 'churay',
-        set: 'churay',
-        get: 'chaskiy',
+        // churay is the semantic qu profile's `put` primary; `set` is churanay. Emitting
+        // churay for set made the semantic parser read a transformed `set` as `put`.
+        // See ZH_BLOCK_BODY_SCOPE.md (#2 sweep — keyword realignment, cf. zh fetch).
+        set: 'churanay',
+        // Align with the semantic quechua profile's `get` primary (`taripay`); the
+        // previous `chaskiy` had no profile entry, so the transformed `get` dropped
+        // (get-value parsed degenerate). Same dict↔profile alignment as id `toggle`.
+        get: 'taripay',
         add: 'yapay',
         remove: 'qichuy',
         toggle: 'tikray',
         hide: 'pakay',
         show: 'rikuchiy',
         if: 'sichus',
-        unless: 'mana_sichus',
-        repeat: 'kutichiy',
-        for: 'rayku',
-        while: 'kay_kaq',
+        unless: 'mana sichus', // spaced phrase ("if not"); `_` form split to `mana`+`sichus`(=if) at parse time
+        repeat: 'kutipay',
+        for: 'sapankaq', // profile's for word — rayku doubles as `by`
+        // `kaykamaqa` (the semantic qu profile's while primary), not `kay_kaq`: the
+        // `_` form is unknown to the profile (and `_` words split at parse time, cf.
+        // qhipaman_yapay), so the fronted repeat-while head never formed a `while`
+        // node — the condition dropped wholesale. Same dict↔profile alignment as
+        // vi render / de abrufen.
+        while: 'kaykamaqa',
         until: 'hayk_akama',
         continue: 'purichiy',
         break: 'p_akiy',
@@ -2669,12 +2793,18 @@ const qu$1 = {
         call: 'qayay',
         return: 'kutimuy',
         make: 'ruray',
-        log: 'qillqay',
+        // qillqay is the semantic qu profile's `copy` primary; `log` is qillqakuy.
+        // Emitting qillqay for log made the parser read every transformed log as
+        // copy (log-value/log-element/get-value lossy) — same realign as set above.
+        log: 'qillqakuy',
         throw: 'wikchuy',
         catch: 'hapsiy',
         measure: 'tupuy',
-        transition: 'tikray',
-        increment: 'yapay',
+        // pasay, not tikray: the semantic qu profile's toggle keyword is
+        // t'ikray/tikray, so a tikray render collided with toggle and the
+        // transition command never anchored (sw kama precedent, #569).
+        transition: 'pasay',
+        increment: 'yapachiy',
         decrement: 'pisiyachiy',
         default: 'ñawpaq_kaq',
         go: 'riy',
@@ -2685,13 +2815,13 @@ const qu$1 = {
         beep: 'waqay',
         js: 'js',
         async: 'mana_suyaspa',
-        render: 'rikuchiy',
-        swap: 'rantin_tikray',
-        morph: 'tikrachiy',
-        settle: 'tiyay',
-        append: 'qhipaman_yapay',
+        render: 'rikurichiy', // auditor: dict emitted a word the profile reads differently
+        swap: "t'inkuy", // profile primary; 'rantin_tikray' splits, 'tikray' is toggle's word
+        morph: 'tukunay', // auditor: dict emitted a word the profile reads differently
+        settle: 'tiyakuy', // auditor: dict emitted a word the profile reads differently
+        append: 'qatichiy', // profile's append primary (single token); `qhipaman_yapay` `_`-split to qhipaman+yapay(=add) at parse time
         exit: 'lluqsiy',
-        install: 'churay',
+        install: 'tarpuy',
         breakpoint: 'sayachinay',
         clear: 'pichay',
         close: 'wichqay',
@@ -2699,6 +2829,7 @@ const qu$1 = {
         select: 'akllay',
         clone: 'kikinchay',
         prepend: 'ñawpachiy',
+        socket: 'tinkina',
     },
     modifiers: {
         to: 'man',
@@ -2721,8 +2852,10 @@ const qu$1 = {
     events: {
         click: 'ñitiy',
         dblclick: 'iskay_ñitiy',
-        mousedown: 'rat_ñitiy',
-        mouseup: 'rat_huqariy',
+        // Fused (no `_`): the semantic tokenizer splits on `_` — and `rat_ñitiy` then
+        // mis-captured as the `click` event (ñitiy→click). Mirrors the #535 ru/uk fuse.
+        mousedown: 'ratñitiy',
+        mouseup: 'rathuqariy',
         mouseenter: 'rat_yaykuy',
         mouseleave: 'rat_lluqsiy',
         mouseover: 'rat_hawapi',
@@ -2761,7 +2894,11 @@ const qu$1 = {
         has: 'kachkan',
         have: 'kachkani',
         then: 'chayqa',
-        else: 'mana_chayqa',
+        // Align to the semantic profile's else word `manachus`. The old `mana_chayqa`
+        // tokenized as `mana`(false) + `_` + `chayqa`(then) — no else keyword formed,
+        // so qu conditionals never split their else branch. `manachus` is a single
+        // token the profile-derived keyword map reads as `else` (dict↔profile align).
+        else: 'manachus',
         otherwise: 'huk_kaqpi',
         end: 'tukuy',
         live: 'kawsay',
@@ -2784,7 +2921,7 @@ const qu$1 = {
     values: {
         true: 'cheqaq',
         false: 'llulla',
-        null: 'ch_usaq',
+        null: 'chusaq',
         undefined: 'mana_riqsisqa',
         it: 'chay',
         its: 'chaypaq',
@@ -2822,12 +2959,12 @@ const qu$1 = {
         prev: 'ñawpaq',
         at: 'pi',
         random: 'imaymanata',
-        closest: 'aswan_kaylla',
+        closest: 'kaylla',
         parent: 'mama_tayta',
         children: 'wawakuna',
         within: 'ukupi',
         no: 'mana_kanchu',
-        empty: 'ch_usaq',
+        empty: 'chusaq',
         some: 'wakin',
         'starts with': 'qallarisqa wan',
         'ends with': 'tukusqa wan',
@@ -2879,11 +3016,17 @@ const sw$1 = {
         send: 'tuma',
         take: 'chukua',
         put: 'weka',
-        set: 'weka',
+        // weka is the semantic sw profile's `put` primary; `set` is seti. Emitting weka
+        // for set made the semantic parser read a transformed `set` as `put`.
+        // See ZH_BLOCK_BODY_SCOPE.md (#2 sweep — keyword realignment, cf. zh fetch).
+        set: 'seti',
         get: 'pata',
         add: 'ongeza',
         remove: 'ondoa',
         toggle: 'badilisha',
+        // command blur (the events section has the blur EVENT word; without this
+        // entry the transformer fell back to it and no profile read it as the verb)
+        blur: 'blur',
         hide: 'ficha',
         show: 'onyesha',
         if: 'kama',
@@ -2899,13 +3042,13 @@ const sw$1 = {
         fetch: 'leta',
         call: 'ita',
         return: 'rudi',
-        make: 'fanya',
+        make: 'tengeneza', // auditor: dict emitted a word the profile reads differently
         log: 'andika',
         throw: 'tupa',
         catch: 'shika',
         measure: 'pima',
         transition: 'mpito',
-        increment: 'ongeza',
+        increment: 'ongezeko',
         decrement: 'punguza',
         default: 'msingi',
         go: 'nenda',
@@ -2918,18 +3061,20 @@ const sw$1 = {
         async: 'sainkroni',
         render: 'chora',
         swap: 'badilishana',
-        morph: 'badilishaUmbo',
+        morph: 'geuza', // auditor: dict emitted a word the profile reads differently
         settle: 'tulia',
-        append: 'ongezaMwisho',
+        append: 'ambatanisha', // profile primary; 'ongezaMwisho' is unrecognized
         exit: 'toka',
         install: 'sakinisha',
         breakpoint: 'nukta-simama',
-        clear: 'futa',
+        clear: 'safisha', // futa is a remove alternative in the profile
         close: 'funga',
         open: 'fungua',
         select: 'chagua',
         clone: 'nakili',
         prepend: 'tanguliza',
+        focus: 'lenga',
+        socket: 'soketi',
     },
     modifiers: {
         to: 'kwa',
@@ -2939,7 +3084,14 @@ const sw$1 = {
         at: 'katika',
         in: 'ndani',
         of: 'ya',
-        as: 'kama',
+        // `kuwa` ("to be/become" — the conversion sense, cf. `badilisha kuwa`), not
+        // `kama`: sw `kama` is the IF keyword (commands.if above and the semantic sw
+        // profile's if primary), so emitting it for `as` grew a phantom `if` command
+        // out of every transformed `as <Type>` tail (`kama JSON`, `kama Number`) when
+        // the semantic parser split event-body statements. Same dict↔profile homonym
+        // disambiguation as pl get/pobierz. The semantic fetch-sw pattern still
+        // tolerates hand-written `kama` in as-marker position.
+        as: 'kuwa',
         by: 'na',
         before: 'kabla',
         after: 'baada',
@@ -2995,7 +3147,7 @@ const sw$1 = {
         else: 'sivyo',
         otherwise: 'vinginevyo',
         end: 'mwisho',
-        live: 'moja_kwa_moja',
+        live: 'mubashara',
         changes: 'inabadilika',
     },
     temporal: {
@@ -3047,13 +3199,25 @@ const sw$1 = {
     },
     expressions: {
         first: 'kwanza',
-        last: 'mwisho',
+        // 'mwisho' is the END keyword (block terminator) — the tokenizer's keyword
+        // map is last-wins, so a positional `last` emission of 'mwisho' reads as
+        // `end` and terminates the enclosing block mid-condition (focus-trap's
+        // `… inafanana mwisho <button/>` dropped the whole branch body). Emit the
+        // concatenated adjective form instead (wa mwisho — the saufsi/wennnicht/
+        // enyakın single-token class); the tokenizer reads it as `last`.
+        last: 'wamwisho',
         next: 'ijayo',
         previous: 'iliyopita',
         prev: 'awali',
         at: 'katika',
         random: 'nasibu',
-        closest: 'karibu_zaidi',
+        // Natural Swahili: `karibu` ("near/close") is the ordinary word and already
+        // maps to closest. The earlier `karibu_zaidi` ("nearer") underscore-split to
+        // karibu/_/zaidi (the stray `_ zaidi` broke positional capture); the fused
+        // `karibuzaidi` parsed but isn't real Swahili. `karibu` alone is both natural
+        // and correct (the sw tokenizer is single-word-only, so a spaced `karibu
+        // zaidi` would strand `zaidi` regardless).
+        closest: 'karibu',
         parent: 'mzazi',
         children: 'watoto',
         within: 'ndani_ya',
@@ -3115,17 +3279,21 @@ const pt$1 = {
         add: 'adicionar',
         remove: 'remover',
         toggle: 'alternar',
+        // command blur (the events section has the blur EVENT word; without this
+        // entry the transformer fell back to it and no profile read it as the verb)
+        blur: 'desfocar',
         hide: 'esconder',
         show: 'mostrar',
         if: 'se',
-        unless: 'a_menos',
+        unless: 'salvo', // a_menos splits at _ in the pt extractor (see profile)
         repeat: 'repetir',
         for: 'para',
         while: 'enquanto',
         until: 'até',
         continue: 'continuar',
-        break: 'parar',
-        halt: 'interromper',
+        // un-crossed: the profile/tokenizer read parar=halt, interromper=break
+        break: 'interromper',
+        halt: 'parar',
         wait: 'esperar',
         fetch: 'buscar',
         call: 'chamar',
@@ -3161,6 +3329,8 @@ const pt$1 = {
         select: 'selecionar',
         clone: 'clonar',
         prepend: 'preceder',
+        focus: 'focar',
+        socket: 'soquete',
     },
     modifiers: {
         to: 'para',
@@ -3284,7 +3454,7 @@ const pt$1 = {
         prev: 'ant',
         at: 'em',
         random: 'aleatório',
-        closest: 'mais_próximo',
+        closest: 'maispróximo',
         parent: 'pai',
         children: 'filhos',
         within: 'dentro',
@@ -3349,7 +3519,7 @@ const it$1 = {
         hide: 'nascondere',
         show: 'mostrare',
         if: 'se',
-        unless: 'a meno che',
+        unless: 'salvo',
         repeat: 'ripetere',
         for: 'per',
         while: 'mentre',
@@ -3382,7 +3552,7 @@ const it$1 = {
         swap: 'scambiare',
         morph: 'trasformare',
         settle: 'stabilizzare',
-        append: 'aggiungere',
+        append: 'accodare', // profile primary; 'aggiungere' is add's word (parsed as add)
         exit: 'uscire',
         install: 'installare',
         breakpoint: 'punto-interruzione',
@@ -3392,6 +3562,9 @@ const it$1 = {
         select: 'selezionare',
         clone: 'clonare',
         prepend: 'anteporre',
+        // profile primary; without a commands entry the transformer fell back to
+        // the EVENTS noun 'fuoco', which generated focus patterns can't match
+        focus: 'focalizzare',
     },
     modifiers: {
         to: 'a',
@@ -3515,7 +3688,7 @@ const it$1 = {
         prev: 'prec',
         at: 'a',
         random: 'casuale',
-        closest: 'piùvicino',
+        closest: 'vicino',
         parent: 'genitore',
         children: 'figli',
         within: 'dentro',
@@ -3583,7 +3756,7 @@ const vi$1 = {
         beep: 'beep',
         js: 'js',
         async: 'bất đồng bộ',
-        render: 'hiển thị',
+        render: 'kết xuất', // distinct from `show` (was `hiển thị`, which collides with show: the semantic profile reads `hiển thị` as show, `kết xuất` as render)
         swap: 'hoán đổi',
         morph: 'biến đổi',
         settle: 'ổn định',
@@ -3598,7 +3771,7 @@ const vi$1 = {
         prepend: 'thêm đầu',
         else: 'không thì',
         breakpoint: 'điểm-dừng',
-        clear: 'xóa',
+        clear: 'tẩy', // xóa is the remove PRIMARY in the profile
         close: 'đóng',
         open: 'mở',
         select: 'chọn',
@@ -3662,7 +3835,7 @@ const vi$1 = {
         else: 'không thì',
         end: 'kết thúc',
         then: 'rồi',
-        live: 'trực tiếp',
+        live: 'live',
         changes: 'thay đổi',
     },
     temporal: {
@@ -3749,15 +3922,22 @@ const pl$1 = {
     commands: {
         on: 'gdy',
         tell: 'powiedz',
-        trigger: 'wywołaj',
+        trigger: 'wyzwól', // auditor: dict emitted a word the profile reads differently
         send: 'wyślij',
         take: 'weź',
         put: 'umieść',
         set: 'ustaw',
-        get: 'pobierz',
+        // `uzyskaj` (the semantic pl profile's get primary), not `pobierz`: pl `pobierz`
+        // ("download") is the profile's FETCH primary, so emitting it for get made the
+        // parser read every transformed get as fetch (get-value lossy + a phantom fetch).
+        // Same dict↔profile homonym disambiguation as tr load/install, qu get.
+        get: 'uzyskaj',
         add: 'dodaj',
         remove: 'usuń',
         toggle: 'przełącz',
+        // command blur (the events section has the blur EVENT word; without this
+        // entry the transformer fell back to it and no profile read it as the verb)
+        blur: 'rozmyj',
         hide: 'ukryj',
         show: 'pokaż',
         if: 'jeśli',
@@ -3798,12 +3978,13 @@ const pl$1 = {
         exit: 'wyjdź',
         install: 'zainstaluj',
         breakpoint: 'punkt-przerwania',
-        clear: 'wyczyść',
+        clear: 'zeruj', // wyczyść is a remove alternative in the profile
         close: 'zamknij',
         open: 'otwórz',
         select: 'wybierz',
         clone: 'sklonuj',
         prepend: 'poprzedź',
+        focus: 'skup',
     },
     modifiers: {
         to: 'do',
@@ -3954,7 +4135,7 @@ const russianDictionary = {
     commands: {
         on: 'при',
         tell: 'сказать',
-        trigger: 'вызвать',
+        trigger: 'запустить', // auditor: dict emitted a word the profile reads differently
         send: 'отправить',
         take: 'взять',
         put: 'положить',
@@ -3965,8 +4146,12 @@ const russianDictionary = {
         toggle: 'переключить',
         hide: 'скрыть',
         show: 'показать',
+        // command verb; the events section keeps the noun прокрутка for `on scroll`.
+        // Without this entry the transformer fell back to the event noun, which the
+        // parser doesn't read as the scroll command (#321 focus family).
+        scroll: 'прокрутить',
         if: 'если',
-        unless: 'если_не',
+        unless: 'кроме',
         repeat: 'повторить',
         for: 'для',
         while: 'пока',
@@ -3999,10 +4184,10 @@ const russianDictionary = {
         swap: 'поменять',
         morph: 'трансформировать',
         settle: 'стабилизировать',
-        append: 'добавить_в_конец',
+        append: 'дописать', // profile alternative; the compound splits and добавить parses as add
         exit: 'выйти',
         else: 'иначе',
-        install: 'установить',
+        install: 'инсталлировать', // loanword — `установить` is `set` (homonym); see russian profile
         init: 'инициализировать',
         behavior: 'поведение',
         focus: 'сфокусировать',
@@ -4037,8 +4222,11 @@ const russianDictionary = {
     events: {
         click: 'клик',
         dblclick: 'двойной_клик',
-        mousedown: 'мышь_вниз',
-        mouseup: 'мышь_вверх',
+        // Fused (no `_`): the semantic tokenizer splits on `_`, so an underscore form
+        // breaks event recognition (mousedown → bare expression). Mirrors the #510 tr
+        // resize fix (boyut_değiştir → boyutlandırma) and the enyakın superlative.
+        mousedown: 'мышьвниз',
+        mouseup: 'мышьвверх',
         mouseenter: 'мышь_вход',
         mouseleave: 'мышь_выход',
         mouseover: 'наведение',
@@ -4055,7 +4243,7 @@ const russianDictionary = {
         reset: 'сброс',
         load: 'загрузка',
         unload: 'выгрузка',
-        resize: 'изменение_размера',
+        resize: 'изменениеразмера', // fused (no `_`) — see mousedown note above
         scroll: 'прокрутка',
         touchstart: 'касание_начало',
         touchend: 'касание_конец',
@@ -4185,7 +4373,7 @@ const ukrainianDictionary = {
     commands: {
         on: 'при',
         tell: 'сказати',
-        trigger: 'викликати',
+        trigger: 'запустити', // auditor: dict emitted a word the profile reads differently
         send: 'надіслати',
         take: 'взяти',
         put: 'покласти',
@@ -4196,8 +4384,12 @@ const ukrainianDictionary = {
         toggle: 'перемкнути',
         hide: 'сховати',
         show: 'показати',
+        // command verb; the events section keeps the noun прокрутка for `on scroll`.
+        // Without this entry the transformer fell back to the event noun, which the
+        // parser doesn't read as the scroll command (#321 focus family).
+        scroll: 'прокрутити',
         if: 'якщо',
-        unless: 'якщо_не',
+        unless: 'крім',
         repeat: 'повторити',
         for: 'для',
         while: 'поки',
@@ -4230,10 +4422,10 @@ const ukrainianDictionary = {
         swap: 'поміняти',
         morph: 'трансформувати',
         settle: 'стабілізувати',
-        append: 'додати_в_кінець',
+        append: 'дописати', // profile alternative; the compound splits and додати parses as add
         exit: 'вийти',
         else: 'інакше',
-        install: 'встановити',
+        install: 'інсталювати', // loanword — `встановити` is `set` (homonym); see ukrainian profile
         init: 'ініціалізувати',
         behavior: 'поведінка',
         focus: 'сфокусувати',
@@ -4268,8 +4460,10 @@ const ukrainianDictionary = {
     events: {
         click: 'клік',
         dblclick: 'подвійний_клік',
-        mousedown: 'миша_вниз',
-        mouseup: 'миша_вгору',
+        // Fused (no `_`): the semantic tokenizer splits on `_`, so an underscore form
+        // breaks event recognition. Mirrors the #510 tr resize fix + enyakın.
+        mousedown: 'мишавниз',
+        mouseup: 'мишавгору',
         mouseenter: 'миша_вхід',
         mouseleave: 'миша_вихід',
         mouseover: 'наведення',
@@ -4286,7 +4480,7 @@ const ukrainianDictionary = {
         reset: 'скидання',
         load: 'завантаження',
         unload: 'вивантаження',
-        resize: 'зміна_розміру',
+        resize: 'змінарозміру', // fused (no `_`) — see mousedown note above
         scroll: 'прокрутка',
         touchstart: 'дотик_початок',
         touchend: 'дотик_кінець',
@@ -4428,10 +4622,10 @@ const hindiDictionary = {
         hide: 'छिपाएं',
         show: 'दिखाएं',
         if: 'अगर',
-        unless: 'जब_तक_नहीं',
+        unless: 'जब तक नहीं', // spaced (not जब_तक_नहीं) → one multi-word `unless` token
         repeat: 'दोहराएं',
-        for: 'के_लिए',
-        while: 'जब_तक',
+        for: 'हेतु', // single token — के_लिए splits at _ in the hi extractor
+        while: 'जब तक',
         until: 'तक',
         continue: 'जारी',
         break: 'रोकें',
@@ -4458,10 +4652,10 @@ const hindiDictionary = {
         js: 'जेएस',
         async: 'असिंक',
         render: 'रेंडर',
-        swap: 'बदलें',
+        swap: 'विनिमय',
         morph: 'रूपांतर',
         settle: 'स्थिर',
-        append: 'जोड़ें_अंत',
+        append: 'संलग्न',
         exit: 'बाहर',
         else: 'वरना',
         install: 'इंस्टॉल',
@@ -4476,6 +4670,7 @@ const hindiDictionary = {
         close: 'बंद-करें',
         open: 'खोलें',
         select: 'चुनें',
+        socket: 'सॉकेट',
     },
     modifiers: {
         to: 'को',
@@ -4487,8 +4682,8 @@ const hindiDictionary = {
         of: 'का',
         as: 'के_रूप_में',
         by: 'द्वारा',
-        before: 'से_पहले',
-        after: 'के_बाद',
+        before: 'से पहले',
+        after: 'के बाद',
         over: 'के_ऊपर',
         under: 'के_नीचे',
         between: 'के_बीच',
@@ -4499,8 +4694,10 @@ const hindiDictionary = {
     events: {
         click: 'क्लिक',
         dblclick: 'डबल_क्लिक',
-        mousedown: 'माउस_नीचे',
-        mouseup: 'माउस_ऊपर',
+        // Fused (no `_`): the semantic tokenizer splits on `_`, breaking event
+        // recognition (mousedown → "नीचे"). Mirrors the #535 ru/uk fuse.
+        mousedown: 'माउसनीचे',
+        mouseup: 'माउसऊपर',
         mouseenter: 'माउस_प्रवेश',
         mouseleave: 'माउस_बाहर',
         mouseover: 'माउस_ओवर',
@@ -4532,7 +4729,11 @@ const hindiDictionary = {
         not: 'नहीं',
         is: 'है',
         exists: 'मौजूद',
-        matches: 'मेल_खाता',
+        // Natural spaced phrase `मेल खाता` ("matches") — how Hindi writes it. The base
+        // tokenizer now matches multi-word profile keywords, so the hindi profile maps
+        // `मेल खाता`→matches without the underscore (`मेल_खाता` split) or the
+        // concatenated `मेलखाता` (parsed, but unnatural) workarounds.
+        matches: 'मेल खाता',
         contains: 'शामिल',
         includes: 'में_है',
         equals: 'बराबर',
@@ -4674,7 +4875,7 @@ const bengaliDictionary = {
         throw: 'নিক্ষেপ',
         continue: 'চালিয়ে যান',
         make: 'তৈরি করুন',
-        append: 'শেষে যোগ',
+        append: 'জুড়ুন',
         prepend: 'শুরুতে যোগ',
         focus: 'ফোকাস',
         blur: 'ঝাপসা',
@@ -4703,6 +4904,7 @@ const bengaliDictionary = {
         close: 'বন্ধ',
         open: 'খুলুন',
         select: 'নির্বাচন',
+        socket: 'সকেট',
     },
     modifiers: {
         to: 'কে',
@@ -4761,6 +4963,7 @@ const bengaliDictionary = {
         end: 'শেষ',
         then: 'তারপর',
         live: 'লাইভ',
+        bind: 'বাইন্ড',
         changes: 'পরিবর্তিত হলে',
     },
     temporal: {
@@ -4860,7 +5063,9 @@ const thaiDictionary = {
         prepend: 'เพิ่มหน้า',
         focus: 'โฟกัส',
         blur: 'เบลอ',
-        transition: 'เปลี่ยน',
+        // เปลี่ยนผ่าน, not เปลี่ยน: the semantic th profile's `change` keyword is
+        // เปลี่ยน, so a เปลี่ยน render could never anchor a transition command.
+        transition: 'เปลี่ยนผ่าน',
         settle: 'คงที่',
         measure: 'วัด',
         async: 'อะซิงค์',
@@ -5067,10 +5272,11 @@ const malayDictionary = {
         init: 'mula',
         clone: 'klon',
         breakpoint: 'titik-henti',
-        clear: 'padam',
+        clear: 'bersihkan', // padam is a remove alternative in the profile
         close: 'tutup',
         open: 'buka',
         select: 'pilih',
+        socket: 'soket', // derived from the ms profile (socket.primary); see generate-i18n-dictionaries
     },
     modifiers: {
         to: 'ke',
@@ -5247,10 +5453,13 @@ const tagalogDictionary = {
         tell: 'sabihin',
         trigger: 'palitawin',
         send: 'ipadala',
-        take: 'kunin',
+        take: 'kumuha', // auditor: dict emitted a word the profile reads differently
         put: 'ilagay',
         set: 'itakda',
-        get: 'kuhanin',
+        // Align with the semantic tl profile's `get` primary (`kunin`); the previous
+        // `kuhanin` is the base of fetch's `kuhanin_mula`, so the transformed `get`
+        // dropped (get-value parsed degenerate). Same dict↔profile alignment as id `toggle`.
+        get: 'kunin',
         add: 'idagdag',
         remove: 'alisin',
         toggle: 'palitan',
@@ -5274,7 +5483,7 @@ const tagalogDictionary = {
         throw: 'ihagis',
         catch: 'hulihin',
         measure: 'sukatin',
-        transition: 'baguhin',
+        transition: 'lumipat',
         increment: 'dagdagan',
         decrement: 'bawasan',
         default: 'pamantayan',
@@ -5286,10 +5495,10 @@ const tagalogDictionary = {
         beep: 'tunog',
         js: 'js',
         async: 'sabay',
-        render: 'ipakita',
+        render: 'irender', // auditor: dict emitted a word the profile reads differently
         swap: 'palitan_pwesto',
-        morph: 'baguhin_hugis',
-        settle: 'ayusin',
+        morph: 'baguhin', // auditor: dict emitted a word the profile reads differently
+        settle: 'magpatahimik', // auditor: dict emitted a word the profile reads differently
         append: 'idagdag_sa_dulo',
         prepend: 'idagdag_sa_simula',
         exit: 'lumabas',
@@ -5317,7 +5526,11 @@ const tagalogDictionary = {
         as: 'bilang',
         by: 'sa_pamamagitan_ng',
         before: 'bago',
-        after: 'pagkatapos',
+        // `matapos` (not `pagkatapos`) for the positional "after": `pagkatapos` is
+        // also Tagalog "then", so emitting it for the position modifier collides with
+        // the sequence connector. `matapos` is the unambiguous positional form and
+        // matches the semantic tl profile's `after`.
+        after: 'matapos',
         over: 'sa_ibabaw',
         under: 'sa_ilalim',
         between: 'sa_pagitan',
@@ -5483,6 +5696,7 @@ const he$1 = {
         beep: 'ביפ',
         break: 'שבור',
         call: 'קרא',
+        clear: 'נקה', // profile's clear word — was untranslated (parsed as nothing)
         continue: 'המשך',
         copy: 'העתק',
         decrement: 'הקטן',
@@ -5495,6 +5709,7 @@ const he$1 = {
         halt: 'עצור',
         hide: 'הסתר',
         if: 'אם',
+        unless: 'אלא',
         increment: 'הגדל',
         install: 'התקן',
         js: 'js',
@@ -5509,6 +5724,7 @@ const he$1 = {
         render: 'רנדר',
         repeat: 'חזור',
         return: 'החזר',
+        scroll: 'גלול',
         send: 'שלח',
         set: 'קבע',
         settle: 'התייצב',
@@ -5546,6 +5762,7 @@ const he$1 = {
         end: 'סוף',
         then: 'אז',
         live: 'חי',
+        bind: 'קשור',
         changes: 'משתנה',
         when: 'כאשר',
         where: 'איפה',
@@ -5564,7 +5781,9 @@ const he$1 = {
         your: 'שלך',
     },
     attributes: {},
-    expressions: {},
+    expressions: {
+        last: 'אחרון',
+    },
 };
 
 // packages/i18n/src/parser/he.ts
@@ -5810,6 +6029,13 @@ const en$1 = {
         increment: 'increment',
         decrement: 'decrement',
         default: 'default',
+        // Reactivity Commands
+        bind: 'bind',
+        // Realtime / service-worker Commands
+        eventsource: 'eventsource',
+        socket: 'socket',
+        worker: 'worker',
+        intercept: 'intercept',
         // Navigation Commands
         go: 'go',
         pushUrl: 'pushUrl',
@@ -6281,7 +6507,26 @@ function reorderRoles(roles, targetOrder) {
 function insertMarkers(elements, markers, adpositionType) {
     const result = [];
     for (const element of elements) {
-        const marker = markers.find(m => m.role === element.role);
+        let marker = markers.find(m => m.role === element.role);
+        // A selector-shaped "event" is never a trigger. It's the dangling target of
+        // a locative `on` (`set @role to "alert" on #sr-announce`) that
+        // splitOnCommandBoundaries splits off as a headless pseudo-handler (set/put
+        // are deliberately NOT in ON_TARGET_COMMANDS — dual-destination collision).
+        // Emitting the event marker after it (ko 할 때, ja で, bn এ, tr de) plants a
+        // spurious mid-stream event anchor in the emission; suppress the marker and
+        // emit the bare selector, which body parsers skip harmlessly.
+        if (marker?.role === 'event' && /^[#.<@[]/.test(element.translated || element.value)) {
+            marker = undefined;
+        }
+        // A pronoun-valued "duration" is never a time expression. It's the target
+        // phrase of `take … for me` (en maps `for` → duration lexically), kept
+        // in-clause by splitOnCommandBoundaries' loop-head guard. Emitting the
+        // duration marker after it (bn জন্য — also bn's `for` loop keyword) anchors
+        // a spurious `for` command in the semantic parse; suppress the marker and
+        // emit the bare pronoun, which take-pattern matchers skip harmlessly.
+        if (marker?.role === 'duration' && /^(me|you|it)$/i.test(element.value)) {
+            marker = undefined;
+        }
         if (marker) {
             if (adpositionType === 'preposition') {
                 // Marker before element: "to element"
@@ -6455,6 +6700,41 @@ const japaneseProfile = {
                 insertMarkers: true,
             },
         },
+        {
+            name: 'set-to',
+            description: 'Transform set X to Y to Japanese verb-final order',
+            priority: 90,
+            match: {
+                commands: ['set', '設定'],
+                requiredRoles: ['action', 'patient', 'destination'],
+                // Skip a set whose value swept up a trailing block terminator (`set X to Y
+                // end` — the body of an inline `if … then set … end`): verb-final reorder
+                // would push the verb past `end` and break the block. These parse fine
+                // verb-medial (the default).
+                predicate: parsed => !/(^|\s)end$/i.test((parsed.original ?? '').trim()),
+            },
+            transform: {
+                // X を Y に 設定 — verb-final, matching the generated SOV set pattern
+                // (markerOverride: を on the destination / に on the value). Default reorder
+                // emitted verb-MEDIAL (`X を 設定 Y に`), unmatched by any set pattern.
+                roleOrder: ['patient', 'destination', 'action'],
+                insertMarkers: true,
+            },
+        },
+        {
+            name: 'bind-to',
+            description: 'Transform bind $var to #el to Japanese verb-final order',
+            priority: 90,
+            match: {
+                commands: ['bind', 'バインド'],
+                requiredRoles: ['action', 'patient', 'destination'],
+            },
+            transform: {
+                // $var を #el に バインド
+                roleOrder: ['patient', 'destination', 'action'],
+                insertMarkers: true,
+            },
+        },
     ],
 };
 // =============================================================================
@@ -6473,6 +6753,10 @@ const koreanProfile = {
         { form: '를', role: 'patient', position: 'postposition', required: true, alternatives: ['을'] },
         { form: '에', role: 'destination', position: 'postposition', required: true },
         { form: '에서', role: 'source', position: 'postposition', required: true },
+        // Event marker — the semantic *-event-ko-sov-* patterns anchor on 할 때
+        // (the generator profile's eventMarker); without it every ko handler
+        // emitted a bare event name no fused pattern could anchor.
+        { form: '할 때', role: 'event', position: 'postposition', required: true },
         {
             form: '로',
             role: 'style',
@@ -6503,6 +6787,56 @@ const koreanProfile = {
                 insertMarkers: true,
             },
         },
+        {
+            name: 'put-into',
+            description: 'Transform put X into Y to Korean verb-final order',
+            priority: 90,
+            match: {
+                commands: ['put', '넣다'],
+                requiredRoles: ['action', 'patient', 'destination'],
+                // Standalone put only (e.g. a then-chain clause): an event handler whose
+                // action is `put` must keep the event mid-stream, so don't verb-final it.
+                predicate: parsed => !parsed.roles.has('event'),
+            },
+            transform: {
+                // X 를 Y 에 넣다 (patient, destination, verb-last)
+                roleOrder: ['patient', 'destination', 'action'],
+                insertMarkers: true,
+            },
+        },
+        {
+            name: 'set-to',
+            description: 'Transform set X to Y to Korean verb-final order',
+            priority: 90,
+            match: {
+                commands: ['set', '설정'],
+                requiredRoles: ['action', 'patient', 'destination'],
+                // Skip a set whose value swept up a trailing block terminator (`set X to Y
+                // end` — the body of an inline `if … then set … end`): verb-final reorder
+                // would push the verb past `end` and break the block. These parse fine
+                // verb-medial (the default).
+                predicate: parsed => !/(^|\s)end$/i.test((parsed.original ?? '').trim()),
+            },
+            transform: {
+                // X 를 Y 에 설정 — verb-final, matching the generated SOV set pattern.
+                roleOrder: ['patient', 'destination', 'action'],
+                insertMarkers: true,
+            },
+        },
+        {
+            name: 'bind-to',
+            description: 'Transform bind $var to #el to Korean verb-final order',
+            priority: 90,
+            match: {
+                commands: ['bind', '바인드'],
+                requiredRoles: ['action', 'patient', 'destination'],
+            },
+            transform: {
+                // $var 를 #el 에 바인드
+                roleOrder: ['patient', 'destination', 'action'],
+                insertMarkers: true,
+            },
+        },
     ],
 };
 // =============================================================================
@@ -6537,19 +6871,29 @@ const chineseProfile = {
                 requiredRoles: ['event', 'action'],
             },
             transform: {
-                // 当 点击 时 增加 #count
+                // 当 EVENT 时 ACTION [patient] [destination] [source] [style] [method] ...
                 roleOrder: ['event', 'action', 'patient'],
                 insertMarkers: true,
-                custom: (parsed, _profile) => {
-                    // Handle 当...时 circumfix
+                custom: (parsed, profile) => {
+                    // Handle 当...时 circumfix wrapping the event, then emit the action,
+                    // then any remaining roles in canonical order with their markers.
+                    // Earlier this function emitted only event/action/patient and silently
+                    // dropped destination, source, style, etc. — that produced truncated
+                    // output for `send X to Y`, `fetch /api with method:...`, etc.
                     const event = parsed.roles.get('event');
                     const action = parsed.roles.get('action');
-                    const patient = parsed.roles.get('patient');
-                    const parts = ['当', event?.translated || event?.value, '时'];
-                    parts.push(action?.translated || action?.value || '');
-                    if (patient) {
-                        parts.push(patient.translated || patient.value);
-                    }
+                    // Build the post-action role list using the canonical order minus
+                    // event/action, plus a safety net for any roles not in the order.
+                    const remaining = new Map(parsed.roles);
+                    remaining.delete('event');
+                    remaining.delete('action');
+                    const remainingOrder = (profile.canonicalOrder || []).filter(r => r !== 'event' && r !== 'action');
+                    const reordered = reorderRoles(remaining, remainingOrder);
+                    const markedTokens = insertMarkers(reordered, profile.markers, profile.adpositionType);
+                    const parts = ['当', event?.translated || event?.value || '', '时'];
+                    if (action)
+                        parts.push(action.translated || action.value);
+                    parts.push(...markedTokens);
                     return parts.filter(Boolean).join(' ');
                 },
             },
@@ -6568,6 +6912,30 @@ const chineseProfile = {
                 insertMarkers: true,
             },
         },
+        {
+            name: 'bind-to',
+            description: 'Bind binds a variable to an element: 绑定 X 到 Y (no 把)',
+            priority: 90,
+            match: {
+                commands: ['bind', '绑定'],
+                requiredRoles: ['action', 'patient', 'destination'],
+            },
+            transform: {
+                // Plain SVO without the 把 object-fronting: the bound variable is the
+                // semantic destination (not a fronted patient), and `到` marks the
+                // target element. Custom so the patient does not pick up 把.
+                roleOrder: ['action', 'patient', 'destination'],
+                custom: parsed => {
+                    const action = parsed.roles.get('action');
+                    const patient = parsed.roles.get('patient');
+                    const destination = parsed.roles.get('destination');
+                    const verb = action?.translated || action?.value || '';
+                    const v = patient?.translated || patient?.value || '';
+                    const d = destination?.translated || destination?.value || '';
+                    return [verb, v, '到', d].filter(Boolean).join(' ');
+                },
+            },
+        },
     ],
 };
 // =============================================================================
@@ -6664,6 +7032,56 @@ const turkishProfile = {
                 insertMarkers: true,
             },
         },
+        {
+            name: 'put-into',
+            description: 'Transform put X into Y to Turkish verb-final order',
+            priority: 90,
+            match: {
+                commands: ['put', 'koy'],
+                requiredRoles: ['action', 'patient', 'destination'],
+                // Standalone put only (e.g. a then-chain clause): an event handler whose
+                // action is `put` must keep the event mid-stream, so don't verb-final it.
+                predicate: parsed => !parsed.roles.has('event'),
+            },
+            transform: {
+                // X i Y e koy (patient, destination, verb-last)
+                roleOrder: ['patient', 'destination', 'action'],
+                insertMarkers: true,
+            },
+        },
+        {
+            name: 'set-to',
+            description: 'Transform set X to Y to Turkish verb-final order',
+            priority: 90,
+            match: {
+                commands: ['set', 'ayarla'],
+                requiredRoles: ['action', 'patient', 'destination'],
+                // Skip a set whose value swept up a trailing block terminator (`set X to Y
+                // end` — the body of an inline `if … then set … end`): verb-final reorder
+                // would push the verb past `end` and break the block. These parse fine
+                // verb-medial (the default).
+                predicate: parsed => !/(^|\s)end$/i.test((parsed.original ?? '').trim()),
+            },
+            transform: {
+                // X i Y e ayarla — verb-final, matching the generated SOV set pattern.
+                roleOrder: ['patient', 'destination', 'action'],
+                insertMarkers: true,
+            },
+        },
+        {
+            name: 'bind-to',
+            description: 'Transform bind $var to #el to Turkish verb-final order',
+            priority: 90,
+            match: {
+                commands: ['bind'],
+                requiredRoles: ['action', 'patient', 'destination'],
+            },
+            transform: {
+                // $var i #el e bağla
+                roleOrder: ['patient', 'destination', 'action'],
+                insertMarkers: true,
+            },
+        },
     ],
 };
 // =============================================================================
@@ -6773,6 +7191,30 @@ const indonesianProfile = {
     ],
 };
 // =============================================================================
+// Malay (SVO, Austronesian) — grammar mirrors Indonesian (shared function words:
+// pada / ke / dari / dengan / sebagai). Without this profile the transformer threw
+// "Unknown target locale: ms", so no ms translation could be generated at all.
+// =============================================================================
+const malayProfile = {
+    code: 'ms',
+    name: 'Bahasa Melayu',
+    wordOrder: 'SVO',
+    adpositionType: 'preposition',
+    morphology: 'agglutinative',
+    direction: 'ltr',
+    canonicalOrder: ['event', 'action', 'patient', 'destination'],
+    markers: [
+        // ms marks the event clause with `apabila` ("when/on") — matching the semantic
+        // ms event-handler pattern (`apabila {event} {body}`) and the ms dict's
+        // `on: apabila`. (Indonesian uses `pada` here; the two diverge on the event head.)
+        { form: 'apabila', role: 'event', position: 'preposition', required: true },
+        { form: 'ke', role: 'destination', position: 'preposition', required: false },
+        { form: 'dari', role: 'source', position: 'preposition', required: false },
+        { form: 'dengan', role: 'style', position: 'preposition', required: false },
+        { form: 'sebagai', role: 'method', position: 'preposition', required: false },
+    ],
+};
+// =============================================================================
 // Quechua (SOV, Quechuan)
 // =============================================================================
 const quechuaProfile = {
@@ -6811,7 +7253,10 @@ const swahiliProfile = {
         { form: 'kwa', role: 'destination', position: 'preposition', required: false },
         { form: 'kutoka', role: 'source', position: 'preposition', required: false },
         { form: 'na', role: 'style', position: 'preposition', required: false },
-        { form: 'kama', role: 'method', position: 'preposition', required: false }, // "as/like"
+        // `kuwa`, not `kama`: sw `kama` is the IF keyword — rendering the method
+        // role ("as X") with it grew a phantom `if` at semantic parse time. See the
+        // matching comment in dictionaries/sw.ts (modifiers.as).
+        { form: 'kuwa', role: 'method', position: 'preposition', required: false }, // "as/become"
     ],
 };
 // =============================================================================
@@ -6852,6 +7297,56 @@ const bengaliProfile = {
                 insertMarkers: true,
             },
         },
+        {
+            name: 'put-into',
+            description: 'Transform put X into Y to Bengali verb-final order',
+            priority: 90,
+            match: {
+                commands: ['put', 'রাখুন'],
+                requiredRoles: ['action', 'patient', 'destination'],
+                // Standalone put only (e.g. a then-chain clause): an event handler whose
+                // action is `put` must keep the event mid-stream, so don't verb-final it.
+                predicate: parsed => !parsed.roles.has('event'),
+            },
+            transform: {
+                // X কে Y তে রাখুন (patient, destination, verb-last)
+                roleOrder: ['patient', 'destination', 'action'],
+                insertMarkers: true,
+            },
+        },
+        {
+            name: 'set-to',
+            description: 'Transform set X to Y to Bengali verb-final order',
+            priority: 90,
+            match: {
+                commands: ['set', 'সেট'],
+                requiredRoles: ['action', 'patient', 'destination'],
+                // Skip a set whose value swept up a trailing block terminator (`set X to Y
+                // end` — the body of an inline `if … then set … end`): verb-final reorder
+                // would push the verb past `end` and break the block. These parse fine
+                // verb-medial (the default).
+                predicate: parsed => !/(^|\s)end$/i.test((parsed.original ?? '').trim()),
+            },
+            transform: {
+                // X কে Y তে সেট — verb-final, matching the generated SOV set pattern.
+                roleOrder: ['patient', 'destination', 'action'],
+                insertMarkers: true,
+            },
+        },
+        {
+            name: 'bind-to',
+            description: 'Transform bind $var to #el to Bengali verb-final order',
+            priority: 90,
+            match: {
+                commands: ['bind', 'বাইন্ড'],
+                requiredRoles: ['action', 'patient', 'destination'],
+            },
+            transform: {
+                // $var কে #el তে বাইন্ড
+                roleOrder: ['patient', 'destination', 'action'],
+                insertMarkers: true,
+            },
+        },
     ],
 };
 // =============================================================================
@@ -6984,6 +7479,61 @@ const hindiProfile = {
                 insertMarkers: true,
             },
         },
+        {
+            name: 'put-into',
+            description: 'Transform put X into Y to Hindi verb-final order',
+            priority: 90,
+            match: {
+                commands: ['put', 'रखें'],
+                requiredRoles: ['action', 'patient', 'destination'],
+            },
+            transform: {
+                // "hi" को #out में रखें
+                roleOrder: ['patient', 'destination', 'action'],
+                insertMarkers: true,
+            },
+        },
+        {
+            name: 'set-to',
+            description: 'Transform set X to Y to Hindi verb-final order',
+            priority: 90,
+            match: {
+                commands: ['set', 'सेट'],
+                requiredRoles: ['action', 'patient', 'destination'],
+                // Skip a set whose value swept up a trailing block terminator (`set X to Y
+                // end` — the body of an inline `if … then set … end`): verb-final reorder
+                // would push the verb past `end` and break the block. These parse fine
+                // verb-medial (the default).
+                predicate: parsed => !/(^|\s)end$/i.test((parsed.original ?? '').trim()),
+            },
+            transform: {
+                // #x.innerText को इसका.name में सेट — verb-final, matching the generated
+                // SOV set pattern (set schema markerOverride puts को on the destination /
+                // में on the value). The default reorder emitted verb-MEDIAL
+                // (`#x को सेट … में`), which no set pattern matched → bare-event fallback.
+                roleOrder: ['patient', 'destination', 'action'],
+                insertMarkers: true,
+            },
+        },
+        {
+            name: 'bind-to',
+            description: 'Transform bind $var to #el to Hindi verb-final order',
+            priority: 90,
+            match: {
+                commands: ['bind', 'बाइंड', 'बांधें'],
+                requiredRoles: ['action', 'patient', 'destination'],
+            },
+            transform: {
+                // $greeting को #name-input में bind — verb-final, matching the generated SOV
+                // bind pattern (`{destination} को {source} में bind`). The default reorder
+                // emitted verb-MEDIAL (`$greeting को bind #name-input में`), which the
+                // verb-final pattern never matched → the bare-event fallback mis-anchored
+                // the fronted `$greeting` as a phantom `on` event (the rf=0.00 bind residue).
+                // ja/ko/zh/tr/bn already carry this rule; hi was the only SOV gap.
+                roleOrder: ['patient', 'destination', 'action'],
+                insertMarkers: true,
+            },
+        },
     ],
 };
 // =============================================================================
@@ -7001,7 +7551,11 @@ const tagalogProfile = {
     markers: [
         { form: 'kapag', role: 'event', position: 'preposition', required: true },
         { form: 'sa', role: 'destination', position: 'preposition', required: false },
-        { form: 'mula sa', role: 'source', position: 'preposition', required: false },
+        // mula_sa (underscore) matches the tl dict and the semantic profile's
+        // source marker — the spaced form emitted two tokens the generated
+        // patterns' single mula_sa literal could never match, so `remove X
+        // mula sa Y` lost its source and the schema default fabricated me.
+        { form: 'mula_sa', role: 'source', position: 'preposition', required: false },
         { form: 'nang', role: 'style', position: 'preposition', required: false },
         { form: 'bilang', role: 'method', position: 'preposition', required: false },
     ],
@@ -7091,6 +7645,32 @@ const hebrewProfile = {
         { form: 'עם', role: 'style', position: 'preposition', required: false },
         { form: 'כ', role: 'method', position: 'preposition', required: false },
     ],
+    rules: [
+        {
+            name: 'bind-to',
+            description: 'Bind binds a variable to an element: קשור X ל Y',
+            priority: 90,
+            match: {
+                commands: ['bind', 'קשור'],
+                requiredRoles: ['action', 'patient', 'destination'],
+            },
+            transform: {
+                // The bound variable is the semantic destination (kept bare, no את
+                // object marker), and ל marks the target element. Custom so the
+                // variable does not pick up את and the element uses ל (not על).
+                roleOrder: ['action', 'patient', 'destination'],
+                custom: parsed => {
+                    const action = parsed.roles.get('action');
+                    const patient = parsed.roles.get('patient');
+                    const destination = parsed.roles.get('destination');
+                    const verb = action?.translated || action?.value || '';
+                    const v = patient?.translated || patient?.value || '';
+                    const d = destination?.translated || destination?.value || '';
+                    return [verb, v, 'ל', d].filter(Boolean).join(' ');
+                },
+            },
+        },
+    ],
 };
 // =============================================================================
 // Profile Registry
@@ -7107,6 +7687,7 @@ const profiles = {
     fr: frenchProfile,
     pt: portugueseProfile,
     id: indonesianProfile,
+    ms: malayProfile,
     qu: quechuaProfile,
     sw: swahiliProfile,
     bn: bengaliProfile,
@@ -7585,6 +8166,95 @@ function getCommandKeywordsForLocale(locale) {
     }
     return keywords;
 }
+/**
+ * English copula forms. A command keyword IMMEDIATELY after one of these is a
+ * predicate adjective, not a command verb: in `if my value is empty add .error
+ * to me` the `empty` belongs to the condition (`empty` is also a hyperscript
+ * command, v0.9.90). Without this guard the condition/body scans cut the
+ * condition at `is` and displace the adjective into the body's argument zone,
+ * where it anchors a spurious `empty-{lang}-generated` parse AND steals a
+ * neighboring role (the empty ×8 bn/hi/tr family). Source-locale copulas are
+ * added via the dictionary in `isPredicateAdjectivePosition`.
+ */
+const EN_COPULAS = ['is', 'are', 'was', 'were', 'am', 'be'];
+function getCopulasForLocale(locale) {
+    const copulas = new Set(EN_COPULAS);
+    if (locale !== 'en') {
+        for (const form of EN_COPULAS) {
+            copulas.add(translateWord(form, 'en', locale).toLowerCase());
+        }
+    }
+    return copulas;
+}
+/**
+ * True when tokens[i] sits right after a copula — a predicate-adjective
+ * position that must never be read as the start of a body command.
+ */
+function isPredicateAdjectivePosition(tokens, i, copulas) {
+    const prev = tokens[i - 1]?.toLowerCase();
+    return !!prev && copulas.has(prev);
+}
+/**
+ * Source-locale surface forms of the `for` command keyword and the loop's
+ * `in` preposition, for the loop-head test below.
+ */
+function getForLoopWordsForLocale(locale) {
+    const forWords = new Set(['for']);
+    const inWords = new Set(['in']);
+    if (locale !== 'en') {
+        forWords.add(translateWord('for', 'en', locale).toLowerCase());
+        inWords.add(translateWord('in', 'en', locale).toLowerCase());
+    }
+    return { forWords, inWords };
+}
+/**
+ * True when a `for` at tokens[i] heads a real loop. Hyperscript's only
+ * statement-head `for` is `for <var> in <iterable>`, so a `for` with no `in`
+ * among the tokens before the next command keyword is a ROLE PHRASE — take's
+ * target (`take .active from .tab-button for me`) or a duration (`for 2s`) —
+ * and must never split the statement: the split shattered the phrase into a
+ * dangling `then for me` clause, which six SOV languages then parsed as a
+ * spurious `for` loop with patient "me" (the take-class ×6 family).
+ */
+function isLoopHeadFor(tokens, i, inWords, commandKeywords) {
+    for (let j = i + 1; j < tokens.length; j++) {
+        const lt = tokens[j].toLowerCase();
+        if (inWords.has(lt))
+            return true;
+        if (commandKeywords.has(lt))
+            return false;
+    }
+    return false;
+}
+/**
+ * Repair a FRONTED Hebrew accusative marker in transformed output.
+ *
+ * When an event-handler body leads with a command-modifier (`on click once add …`,
+ * via {@link GrammarTransformer.tryTransformEventWithModifierBody}) or is a control
+ * block (`on blur if … add … end`, via `tryTransformEventWithBlockBody`), the body
+ * command's accusative marker את can be emitted AHEAD of its verb — `add .error to me`
+ * renders `… את הוסף .error …` instead of the canonical `… הוסף את .error …`. את before
+ * a verb is always ungrammatical Hebrew (it only ever marks a FOLLOWING definite
+ * object), and the semantic parser drops the command in every parse path (fused-event,
+ * multi-clause, conditional-body) when the marker is fronted but parses it when the
+ * marker follows the verb. So an `<accusative-marker> <command-verb>` adjacency is a
+ * pure transformer artifact: swap it back. Idempotent and safe — only touches `את
+ * <verb>`, never the ~40 generated `<verb> את {patient}` patterns that embed את legitimately.
+ */
+function repairHebrewFrontedAccusative(text) {
+    const ACC = 'את'; // hebrewProfile.markers patient marker
+    const verbs = getCommandKeywordsForLocale('he');
+    const tokens = text.split(/\s+/);
+    let changed = false;
+    for (let i = 0; i + 1 < tokens.length; i++) {
+        if (tokens[i] === ACC && verbs.has(tokens[i + 1].toLowerCase())) {
+            [tokens[i], tokens[i + 1]] = [tokens[i + 1], tokens[i]];
+            changed = true;
+            i++; // skip the marker we just moved
+        }
+    }
+    return changed ? tokens.join(' ') : text;
+}
 /**
  * Detect a reactive block (`live ... end`, `when X changes Y [end]`,
  * `unless X Y [end]`) and decompose it. Returns `null` when the input
@@ -7642,11 +8312,14 @@ function extractBlockStructure(input, sourceLocale) {
     // `unless <cond> <body>`: condition runs up to the first command
     // keyword in `inner`. Heuristic — works because hyperscript bodies
     // always start with a command verb, and `unless` conditions rarely
-    // contain bare command keywords as values.
+    // contain bare command keywords as values. A candidate right after a
+    // copula (`… is empty`) is a predicate adjective inside the condition,
+    // not a body verb — skip it.
     const commands = getCommandKeywordsForLocale(sourceLocale);
+    const copulas = getCopulasForLocale(sourceLocale);
     let bodyStart = -1;
     for (let i = 0; i < inner.length; i++) {
-        if (commands.has(inner[i].toLowerCase())) {
+        if (commands.has(inner[i].toLowerCase()) && !isPredicateAdjectivePosition(inner, i, copulas)) {
             bodyStart = i;
             break;
         }
@@ -7803,7 +8476,13 @@ function reconstructWithLineStructure(transformedParts, lineMetadata, partToLine
  * - "on <event> <command>" stays together (event handler with first command)
  * - Modifiers like "to", "from" don't trigger splits
  */
-/** Modifier keywords that should not trigger command boundary splits */
+/**
+ * English modifier keywords that should not trigger command boundary splits.
+ * These are the base set; localized equivalents (e.g. Japanese `に`, Spanish
+ * `a`, Arabic `إلى`) are layered on per source locale by
+ * `getBoundaryModifiersForLocale`, so a preposition in a non-English source
+ * is also recognized as a modifier rather than a spurious command boundary.
+ */
 const BOUNDARY_MODIFIERS = new Set([
     'to',
     'into',
@@ -7817,6 +8496,81 @@ const BOUNDARY_MODIFIERS = new Set([
     'of',
     'over',
 ]);
+/**
+ * Boundary modifiers resolved for a given source locale: the English base set
+ * (always kept, since input may mix English keywords) plus every grammatical
+ * marker form declared by the locale's profile. Profile markers are the
+ * surface realizations of semantic roles (destination, source, style, …) —
+ * they always bind to a following value, so none should be treated as a
+ * command boundary. Cached per locale because profiles are static.
+ */
+const boundaryModifiersCache = new Map();
+function getBoundaryModifiersForLocale(locale) {
+    const cached = boundaryModifiersCache.get(locale);
+    if (cached)
+        return cached;
+    const modifiers = new Set(BOUNDARY_MODIFIERS);
+    const profile = getProfile(locale);
+    profile?.markers.forEach(marker => {
+        const form = marker.form.replace(/^-|-$/g, '').toLowerCase();
+        if (form)
+            modifiers.add(form);
+        marker.alternatives?.forEach(alt => {
+            const altForm = alt.replace(/^-|-$/g, '').toLowerCase();
+            if (altForm)
+                modifiers.add(altForm);
+        });
+    });
+    boundaryModifiersCache.set(locale, modifiers);
+    return modifiers;
+}
+/**
+ * Commands for which a trailing `on <element>` is the TARGET the command acts
+ * on (a destination), not a new event-handler clause. For these, the locative
+ * `on` must neither split the statement (`splitOnCommandBoundaries`) nor be read
+ * as a fresh `event` role (`buildArgumentModifierMap`) — see those call sites.
+ *
+ * Deliberately narrow. `on` is overloaded (event-handler head vs. locative
+ * target), and the change has cross-language blast radius, so we only enable
+ * the locative reading for the DOM class/attribute mutators where it's the
+ * documented idiom (`toggle .open on #menu`, `toggle @hidden on #panel`).
+ *
+ * `trigger`/`send` — `trigger X on Y` / `send X on Y` fire an event on a target
+ * element; the trailing `on Y` is that target (destination), not a new clause.
+ * Previously excluded: keeping `on Y` attached produced `trigger X → #y` output
+ * that was thought to destabilise the semantic parser's multi-line behaviour
+ * fallback (behavior-sortable's `trigger sortable:start on me`). That concern is
+ * stale — the recent semantic-parser body increments fold the surrounding block
+ * cleanly, and splitting instead injected a spurious `then` (`disparar
+ * sortable:start entonces en yo`) that glued the following `repeat until event`
+ * loop into a then-chain and dropped it. Keeping `on Y` attached restores
+ * behavior-sortable to faithful across the SVO languages.
+ *
+ * Excluded on purpose:
+ *  - `set` — `set @attr to V on Y` carries BOTH `to` (value) and `on` (target);
+ *    English marks both as `destination`, so remapping `on` would collide with
+ *    and clobber the value. Needs distinct value/target roles first (deferred).
+ *  - `put` — `put X on Y into Z` has the same dual-destination collision.
+ *
+ * `add`/`remove` use `to`/`from` for their target in practice (not `on`), so
+ * their inclusion is a harmless no-op that documents intent.
+ */
+const ON_TARGET_COMMANDS = new Set(['toggle', 'add', 'remove', 'trigger', 'send']);
+/**
+ * Find the command verb of a partially-collected statement: the first command
+ * keyword that is neither the event-handler head (`on`/その他 event markers) nor
+ * an argument-introducing preposition. For `on click toggle .open` → `toggle`;
+ * for `trigger sortable:start` → `trigger`.
+ */
+function commandVerbOf(tokens, commandKeywords) {
+    for (const token of tokens) {
+        const lt = token.toLowerCase();
+        if (commandKeywords.has(lt) && !BOUNDARY_MODIFIERS.has(lt) && !EVENT_KEYWORDS.has(lt)) {
+            return lt;
+        }
+    }
+    return null;
+}
 /**
  * Block-introducing keywords whose body should not be split at command
  * boundaries by `splitOnCommandBoundaries`. Inputs starting with one of
@@ -7829,8 +8583,26 @@ const BOUNDARY_MODIFIERS = new Set([
  * `splitOnThen` + `parseConditional` path.
  */
 const BLOCK_HEAD_KEYWORDS = new Set(['live', 'when', 'unless']);
+/**
+ * Source-language block-introducing command keywords whose body is a clause plus a
+ * branch/loop body (harness source is English, so these are English-keyed). Used to
+ * locate a block body inside an event handler and to track block depth when finding
+ * a top-level `else`.
+ */
+const BLOCK_BODY_KEYWORDS = new Set(['if', 'repeat', 'unless', 'while', 'for']);
+/**
+ * SVO targets that mark the object/patient with a particle (he את, zh 把) and so
+ * mangle an inline `on <event> unless <cond> <body>` guard — the unless tail is
+ * swept into one patient blob and the marker lands ahead of the condition. These
+ * route through `tryTransformEventWithUnlessGuard`. SOV/VSO object-markers
+ * (ja/ko/tr/ar) are excluded: their event does not lead, so the SVO event-first
+ * emission there would be wrong (and they don't exhibit the artifact today).
+ */
+const UNLESS_GUARD_OBJECT_MARKING_LOCALES = new Set(['he', 'zh']);
 function splitOnCommandBoundaries(input, sourceLocale) {
     const commandKeywords = getCommandKeywordsForLocale(sourceLocale);
+    const boundaryModifiers = getBoundaryModifiersForLocale(sourceLocale);
+    const { forWords, inWords } = getForLoopWordsForLocale(sourceLocale);
     const tokens = input.split(/\s+/);
     if (tokens.length === 0)
         return [input];
@@ -7876,7 +8648,48 @@ function splitOnCommandBoundaries(input, sourceLocale) {
                 currentPart.push(token);
                 continue;
             }
-            if (!BOUNDARY_MODIFIERS.has(prevLower) && !commandKeywords.has(prevLower)) {
+            // A `for` that doesn't head a real loop (`for <var> in <iterable>`) is a
+            // role phrase of the current command — see isLoopHeadFor.
+            if (forWords.has(lowerToken) && !isLoopHeadFor(tokens, i, inWords, commandKeywords)) {
+                currentPart.push(token);
+                continue;
+            }
+            // Locative `on` for a DOM-target command (`toggle X on Y`) is the target
+            // element, NOT a new command. `on` lands in `commandKeywords` only
+            // incidentally — the EN dictionary registers `commands.on = 'on'` for the
+            // event-handler head — so without this guard the destination `on` split
+            // the statement, the join re-inserted a spurious `then` (ثم/pagkatapos/…),
+            // and the dangling `on Y` was misread as a second event handler. Keep it
+            // attached so the role parser can assign it to `destination`. Restricted
+            // to ON_TARGET_COMMANDS so `trigger X on me` etc. keep their prior split.
+            if (BOUNDARY_MODIFIERS.has(lowerToken)) {
+                const verb = commandVerbOf(currentPart, commandKeywords);
+                if (verb && ON_TARGET_COMMANDS.has(verb)) {
+                    currentPart.push(token);
+                    continue;
+                }
+                // `set @attr to V on <scope>` (S1 tabs-aria): the trailing `on <scope>`
+                // is the element(s) the attribute is set on, not a new command. `set` is
+                // deliberately NOT in ON_TARGET_COMMANDS (its role parser would clobber
+                // the value), so this is a dedicated guard — kept attached only when a
+                // selector/reference scope follows, then positioned by transformSingle's
+                // set-scope handler (transformSetWithScope). A `set` whose `on` is
+                // followed by a verb is left to split as before.
+                if (lowerToken === 'on' && verb === 'set') {
+                    const nextTok = tokens[i + 1];
+                    const nextLower = nextTok?.toLowerCase();
+                    const scopeLike = !!nextTok &&
+                        (/^[#.<@[]/.test(nextTok) ||
+                            nextLower === 'me' ||
+                            nextLower === 'it' ||
+                            nextLower === 'you');
+                    if (scopeLike) {
+                        currentPart.push(token);
+                        continue;
+                    }
+                }
+            }
+            if (!boundaryModifiers.has(prevLower) && !commandKeywords.has(prevLower)) {
                 // This looks like a command boundary - save current part and start new one
                 parts.push(currentPart.join(' '));
                 currentPart = [token];
@@ -7963,6 +8776,29 @@ function deriveEventKeywordsFromProfiles() {
 }
 /** Event keywords derived from language profiles */
 const EVENT_KEYWORDS = deriveEventKeywordsFromProfiles();
+/**
+ * Conjunctions that join multiple events in an event handler head
+ * (`on click or keypress ...`). Source hyperscript is English, so the
+ * canonical form is `or`; localized equivalents are added defensively for
+ * non-English sources.
+ */
+const EVENT_CONJUNCTIONS = new Set(['or']);
+/**
+ * Command-modifier keywords that may lead an event handler body
+ * (`on click async fetch …`, `on click once add …`). They modify the handler /
+ * following command rather than acting as the verb, so the transformer must lift
+ * them out before role assignment instead of treating them as the action.
+ * Source hyperscript is English, so these are the canonical English forms — the
+ * semantic parser recognizes the same literals when stripping them pre-parse.
+ */
+const BODY_MODIFIER_KEYWORDS = new Set([
+    'async',
+    'once',
+    'debounced',
+    'debounce',
+    'throttled',
+    'throttle',
+]);
 // =============================================================================
 // Helper: Dynamic Modifier Map
 // =============================================================================
@@ -7996,6 +8832,48 @@ function generateModifierMap(profile) {
     }
     return map;
 }
+/**
+ * Modifier map for parsing the ARGUMENTS of a statement (everything after the
+ * command verb), as opposed to the statement head.
+ *
+ * Why a separate map: a few languages reuse one word for both the event-handler
+ * head marker and a locative/target preposition. English is the prime case —
+ * `on` is the event head (`on click …`) AND the toggle/set target preposition
+ * (`toggle .x on #y`). `generateModifierMap` maps `on → event` (from the EN
+ * profile's event marker), so when the destination `on` was read in argument
+ * position it overwrote the already-captured head event (the `click` got
+ * dropped, e.g. `toggle @hidden on #panel` → `… عند #panel` with نقر/click gone).
+ *
+ * The fix: in argument position, remap the event role to `destination`. This is
+ * safe because a trigger event only ever appears at the statement head (which is
+ * consumed before argument parsing begins). Any "event marker" reached while
+ * scanning arguments is therefore being used as a locative — i.e. the element
+ * the command acts ON — which is exactly the `destination` role (the semantic
+ * parser also models `toggle .x on #y` as patient `.x` + destination `#y`).
+ *
+ * Restricted to (a) SVO source profiles and (b) ON_TARGET_COMMANDS:
+ *  - SVO: in VSO/SOV languages the event marker can legitimately appear
+ *    mid-statement (Arabic VSO renders an event handler as `بدل X عند نقر`,
+ *    classified as a command), so remapping there would mis-read a real event
+ *    as a destination. English — and the en→lang gate path — is SVO.
+ *  - command: only the DOM class/attr mutators use a locative `on` target.
+ *    For other commands (`trigger X on me`, `set X to V on Y`) the remap is
+ *    either destabilising or collides with `to`/`into` — see ON_TARGET_COMMANDS.
+ *
+ * When neither applies the unmodified map is returned (event stays event).
+ */
+function buildArgumentModifierMap(profile, actionVerb) {
+    const map = generateModifierMap(profile);
+    const verb = actionVerb?.toLowerCase();
+    if (profile.wordOrder !== 'SVO' || !verb || !ON_TARGET_COMMANDS.has(verb)) {
+        return map;
+    }
+    const remapped = {};
+    for (const [form, role] of Object.entries(map)) {
+        remapped[form] = role === 'event' ? 'destination' : role;
+    }
+    return remapped;
+}
 // =============================================================================
 // Statement Parser
 // =============================================================================
@@ -8102,6 +8980,8 @@ function tokenize(input, profile) {
     let current = '';
     let inSelector = false;
     let selectorDepth = 0;
+    let bracketDepth = 0;
+    let parenDepth = 0;
     for (let i = 0; i < input.length; i++) {
         const char = input[i];
         // Track CSS selector context
@@ -8114,8 +8994,41 @@ function tokenize(input, profile) {
             if (selectorDepth === 0)
                 inSelector = false;
         }
-        // Split on whitespace unless in selector
-        if (/\s/.test(char) && !inSelector) {
+        // Track event-guard / attribute brackets so `[key is 'Escape']` (which has
+        // internal spaces) stays a single token instead of splitting into
+        // `[key` / `is` / `'Escape']` — which mis-assigns `is` as the action verb.
+        if (char === '[') {
+            bracketDepth++;
+        }
+        else if (char === ']' && bracketDepth > 0) {
+            bracketDepth--;
+        }
+        // Track EVERY parenthesized group as a depth scope so it stays ONE token:
+        //
+        // - An ATTACHED `(` (a call or event destructure: `pointerdown(clientX,
+        //   clientY)`, `Resizable(a, b)`) must not split at the comma-space — the
+        //   event-handler-head reorder would separate the halves and drop the
+        //   whole handler (tl behavior-resizable degenerate).
+        // - A STANDALONE `(` opening an expression (`to (the value of #price as
+        //   Number) * (my value as Number)`) must be OPAQUE to role segmentation:
+        //   left loose, its interior `of`/`as`/`from` keywords hit the argument
+        //   modifier map, so the parser split the expression across roles — the
+        //   R1 cluster E mangle (computed-value: the transformer reordered INSIDE
+        //   the parens, embedded the event phrase mid-expression, and dropped the
+        //   whole second operand in every language). Interior keywords still
+        //   translate IN PLACE: role values are re-split on whitespace by
+        //   translateMultiWordValue, and translateWord strips paren punctuation
+        //   before its dictionary lookup (`($count or 0)` → `($count o 0)` in tl —
+        //   the operator translates without the group being torn apart).
+        if (char === '(') {
+            parenDepth++;
+        }
+        else if (char === ')' && parenDepth > 0) {
+            parenDepth--;
+        }
+        // Split on whitespace unless inside a selector, a bracket guard, or an
+        // attached parenthesized argument list
+        if (/\s/.test(char) && !inSelector && bracketDepth === 0 && parenDepth === 0) {
             if (current) {
                 tokens.push(current);
                 current = '';
@@ -8165,11 +9078,26 @@ function parseEventHandler(tokens, profile) {
     let startIndex = EVENT_KEYWORDS.has(tokens[0]?.toLowerCase()) ? 1 : 0;
     // Next token is the event
     if (tokens[startIndex]) {
+        const eventTokens = [tokens[startIndex]];
+        startIndex++;
+        // Fold "or"-conjoined events into the event value (e.g.
+        // "on click or keypress[...] toggle .active"). Without this, "or" would be
+        // read as the action verb and the second event swept into role values,
+        // hoisting "or <event2>" ahead of the command on reorder. Keeping the whole
+        // "<event1> or <event2>" string in the event role lets it translate and
+        // reorder as a single event clause. Only consumes "or" that immediately
+        // follows the event, before any source/action — so a later "or" in a guard
+        // or value is untouched.
+        while (tokens[startIndex] &&
+            EVENT_CONJUNCTIONS.has(tokens[startIndex].toLowerCase()) &&
+            tokens[startIndex + 1]) {
+            eventTokens.push(tokens[startIndex], tokens[startIndex + 1]);
+            startIndex += 2;
+        }
         roles.set('event', {
             role: 'event',
-            value: tokens[startIndex],
+            value: eventTokens.join(' '),
         });
-        startIndex++;
     }
     // Check for event source modifier before the action (e.g., "from #source" in "on input from #firstName set ...")
     // Only handle 'from' (event source) — other modifiers like circumfix markers (Chinese 时) should not be consumed.
@@ -8201,9 +9129,12 @@ function parseEventHandler(tokens, profile) {
         startIndex++;
     }
     // Parse remaining tokens with modifier awareness (like parseCommand does)
-    // This handles "by 3" in "on click increment #count by 3"
+    // This handles "by 3" in "on click increment #count by 3".
+    // Argument map: for DOM-target commands the head event is already captured, so
+    // a locative `on` (`toggle @hidden on #panel`) maps to `destination` rather
+    // than overwriting the head `event`.
     if (tokens[startIndex]) {
-        const modifierMap = generateModifierMap(profile);
+        const modifierMap = buildArgumentModifierMap(profile, roles.get('action')?.value);
         let currentRole = 'patient';
         let currentValue = [];
         for (let i = startIndex; i < tokens.length; i++) {
@@ -8256,9 +9187,11 @@ function parseCommand(tokens, profile) {
         role: 'action',
         value: tokens[0],
     });
-    // Generate dynamic modifier map from language profile
-    // This enables parsing non-English input (e.g., Japanese に, Korean 에, Arabic إلى)
-    const modifierMap = generateModifierMap(profile);
+    // Generate dynamic modifier map from language profile (argument position).
+    // This enables parsing non-English input (e.g., Japanese に, Korean 에, Arabic إلى).
+    // For a DOM-target command a locative `on` (`toggle .active on me`) maps to
+    // `destination` (SVO sources) rather than spawning a bogus `event` role.
+    const modifierMap = buildArgumentModifierMap(profile, tokens[0]);
     let currentRole = 'patient';
     let currentValue = [];
     for (let i = 1; i < tokens.length; i++) {
@@ -8296,6 +9229,72 @@ function parseCommand(tokens, profile) {
         original: tokens.join(' '),
     };
 }
+/**
+ * Re-assign a command's mis-marked primary argument from the default `patient`
+ * role to its true primary role (e.g. `wait`'s leading argument is a `duration`,
+ * not a fronted object).
+ *
+ * The generic argument parser in `parseCommand` / `parseEventHandler` defaults the
+ * first unmarked argument to `patient`. For most commands that is correct, but for a
+ * command whose primary role is a non-patient *and which the target language does not
+ * give a marker* (a duration, a measure — never a BA/object construction), the
+ * `patient` assignment makes `insertMarkers` emit a spurious object-marker (Chinese
+ * `把`, Japanese `を`, Korean `를`). The marked form is ungrammatical and the semantic
+ * parser fails to match it, dropping the command.
+ *
+ * The fix is deliberately scoped to **literal/measure** primary roles
+ * ({@link LITERAL_PRIMARY_ROLES}: `duration`, `quantity`) — values that are *never*
+ * the object of an object-marking construction in any supported language, so moving
+ * them off `patient` can only ever *remove* a spurious marker. Marker-bearing
+ * primaries are intentionally left alone:
+ *  - `set`→destination `到`, `fetch`→source `从` carry a *correct* marker; touching
+ *    them risks no benefit.
+ *  - `send`/`trigger`→event: in a language without an event marker (e.g. Korean has
+ *    no event particle) un-marking the leading argument makes the semantic parser
+ *    mis-read it as a bare event handler and emit a phantom `on` action — an
+ *    over-generation that recall-based fidelity would not catch. So `event`-primary
+ *    commands stay on the `patient` default.
+ *
+ * Roles are still reordered by the safety-net in `reorderRoles`, so no value is lost.
+ * A belt-and-suspenders target-marker guard keeps the change inert should a profile
+ * ever add a marker for one of these literal roles.
+ *
+ * Must run *before* `translateElements`, while the `action` value is still the
+ * source-language (English) keyword, so the schema lookup resolves.
+ *
+ * @see docs-internal/ZH_BLOCK_BODY_SCOPE.md (#1 — transformer role model)
+ */
+const LITERAL_PRIMARY_ROLES = new Set([
+    'duration',
+    'quantity',
+]);
+function applyPrimaryRole(parsed, targetProfile) {
+    // Only re-mark standalone command statements. In an event handler (`on click
+    // wait 2s …`) a verb-final SOV language without an event particle (e.g. Korean)
+    // relies on the leading argument's patient marker as the structural cue that
+    // anchors the handler; un-marking it makes the semantic parser lose the event.
+    // The block-body / then-chain `wait` clauses this fix targets are each parsed as
+    // their own command statement, so they are still covered.
+    if (parsed.type !== 'command')
+        return;
+    const action = parsed.roles.get('action')?.value;
+    if (!action)
+        return;
+    const primaryRole = COMMAND_PRIMARY_ROLES[action.toLowerCase()];
+    if (!primaryRole || !LITERAL_PRIMARY_ROLES.has(primaryRole))
+        return;
+    // Only act on a leading argument the generic parser defaulted to `patient`,
+    // and only when the primary slot isn't already filled by an explicit marker.
+    const patientEl = parsed.roles.get('patient');
+    if (!patientEl || parsed.roles.has(primaryRole))
+        return;
+    // Guard: never introduce a marker that wasn't there. If the target language
+    // marks the primary role, leave the command as-is.
+    if (targetProfile.markers.some(m => m.role === primaryRole))
+        return;
+    parsed.roles.delete('patient');
+    parsed.roles.set(primaryRole, { ...patientEl, role: primaryRole });
+}
 /**
  * Parse a conditional statement
  */
@@ -8315,6 +9314,18 @@ function parseConditional(tokens, _profile) {
             value: conditionValue,
         });
     }
+    else if (thenIndex === -1 && tokens.length > 1) {
+        // Block-style `if <cond>` with the body on following lines (no inline
+        // `then`). Capture everything after `if` as the condition; otherwise the
+        // condition is silently dropped and the rendered block becomes a bare
+        // `if`/`אם`/`如果`, which the semantic block parser then rejects (null
+        // parse). This is the dominant failure for nested control-flow bodies in
+        // non-Latin languages (he, zh).
+        roles.set('condition', {
+            role: 'condition',
+            value: tokens.slice(1).join(' '),
+        });
+    }
     return {
         type: 'conditional',
         roles,
@@ -8336,6 +9347,24 @@ function translateWord(word, sourceLocale, targetLocale) {
     if (/^\d+/.test(word)) {
         return word;
     }
+    // A whole parenthesized group fused by the tokenizer (`(the value of #price
+    // as Number)`) reaching a single-token translate path: translate its
+    // interior word-by-word IN ORDER — never reordered, never re-segmented.
+    if (/\s/.test(word) && word.startsWith('(')) {
+        return word
+            .split(/\s+/)
+            .map(w => translateWord(w, sourceLocale, targetLocale))
+            .join(' ');
+    }
+    // A word carrying paren punctuation from a fused group after whitespace
+    // re-splitting (`(my` / `valor)` / `(($x`): strip the parens for the
+    // dictionary lookup and re-attach, so interior keywords still translate.
+    if (word.length > 1 && (word.startsWith('(') || word.endsWith(')'))) {
+        const m = word.match(/^(\(*)([^()]+)(\)*)$/);
+        if (m && (m[1] || m[3])) {
+            return m[1] + translateWord(m[2], sourceLocale, targetLocale) + m[3];
+        }
+    }
     const sourceDict = sourceLocale === 'en' ? null : dictionaries[sourceLocale];
     const targetDict = dictionaries[targetLocale];
     if (!targetDict)
@@ -8366,9 +9395,21 @@ const POSSESSIVE_MARKERS = {
     ko: { type: 'suffix', marker: '의' },
     zh: { type: 'suffix', marker: '的' },
     ar: { type: 'preposition', marker: 'لـ' },
-    tr: { type: 'suffix', marker: "'ın" },
+    // Spaced genitive particle (not the glued `'ın`), so the tokenizer can split
+    // it off the selector — consistent with Turkish's other spaced case markers.
+    tr: { type: 'particle', marker: 'ın' },
     id: { type: 'preposition', marker: 'dari' },
-    qu: { type: 'suffix', marker: '-pa' },
+    // Latin-script genitive: must be a *spaced* particle (`#picker pa`), since a
+    // glued `#pickerpa` can't be split from the selector by the tokenizer the
+    // way a non-Latin suffix (の/의/র) can.
+    qu: { type: 'particle', marker: 'pa' },
+    // Bengali SOV postposition genitive, like ja/ko — a spaced suffix the
+    // tokenizer splits off as a particle. Previously absent, so it fell back to
+    // the English `'s` marker and its possessive property paths never parsed.
+    // (Hindi `का` is intentionally omitted: its `bind` lacks a verb-final
+    // grammar rule, so fixing its possessive alone yields a wrong `on` parse —
+    // tracked as separate follow-up.)
+    bn: { type: 'suffix', marker: 'র' },
     sw: { type: 'preposition', marker: 'ya' },
 };
 /**
@@ -8405,6 +9446,10 @@ function translatePossessive(token, sourceLocale, targetLocale) {
         case 'suffix':
             // Japanese/Korean/Chinese: owner + marker (e.g., #buttonの, #button의)
             return `${translatedOwner}${targetMarker.marker}`;
+        case 'particle':
+            // Latin-script spaced genitive (Quechua `pa`): owner + space + marker
+            // so the tokenizer can separate it from the selector.
+            return `${translatedOwner} ${targetMarker.marker}`;
         case 'preposition':
             // Will be handled by caller - return marker + owner format
             // Store as special format to be processed later
@@ -8473,6 +9518,20 @@ function translatePossessiveDotNotation(value, sourceLocale, targetLocale) {
  * Also handles possessive dot notation like "my.textContent" → "mi.textContent".
  */
 function translateMultiWordValue(value, sourceLocale, targetLocale) {
+    // Mask event-guard / attribute brackets (`[key is 'Escape']`): their contents
+    // are expression syntax, not translatable keywords — translating `is` -> `ni`
+    // etc. inside them breaks the guard. Restore verbatim after translation.
+    if (value.includes('[')) {
+        const guards = [];
+        const masked = value.replace(/\[[^\]]*\]/g, match => {
+            guards.push(match);
+            return `${guards.length - 1}`;
+        });
+        if (guards.length > 0) {
+            const translated = translateMultiWordValue(masked, sourceLocale, targetLocale);
+            return translated.replace(/(\d+)/g, (_, n) => guards[Number(n)]);
+        }
+    }
     // If it's a single word, check for possessive then translate
     if (!value.includes(' ')) {
         // Check for possessive 's
@@ -8563,6 +9622,35 @@ function translateElements(parsed, sourceLocale, targetLocale) {
     }
 }
 // =============================================================================
+// Caret-scope masking (`^name on <selector>`)
+// =============================================================================
+/** Private-use sentinels bracketing a masked caret-scope index. */
+const CARET_SCOPE_OPEN = '\uE000';
+const CARET_SCOPE_CLOSE = '\uE001';
+/**
+ * Match `^name on <selector>` and the scope's selector form (#id, .class,
+ * <tag/>, [attr]). The `^name` is kept; only the ` on <selector>` scope is masked.
+ */
+const CARET_SCOPE_RE = /(\^[A-Za-z_][\w-]*)(\s+on\s+(?:[#.][\w-]+|<[^>]*\/>|\[[^\]]+\]))/g;
+/**
+ * Mask the ` on <selector>` scope of every `^name on <selector>` read behind an
+ * opaque token attached to `^name`, so the overloaded `on` doesn't reach the
+ * splitter / event-handler parser. Returns null when there's nothing to mask.
+ */
+function maskCaretScopes(input) {
+    const scopes = [];
+    const masked = input.replace(CARET_SCOPE_RE, (_m, varTok, scope) => {
+        const idx = scopes.length;
+        scopes.push(scope);
+        return `${varTok}${CARET_SCOPE_OPEN}${idx}${CARET_SCOPE_CLOSE}`;
+    });
+    return scopes.length > 0 ? { masked, scopes } : null;
+}
+/** Restore masked caret-scope tokens to their verbatim ` on <selector>` form. */
+function restoreCaretScopes(input, scopes) {
+    return input.replace(new RegExp(`${CARET_SCOPE_OPEN}(\\d+)${CARET_SCOPE_CLOSE}`, 'g'), (_m, n) => scopes[Number(n)] ?? '');
+}
+// =============================================================================
 // Main Transformer
 // =============================================================================
 class GrammarTransformer {
@@ -8584,7 +9672,54 @@ class GrammarTransformer {
      * For multi-line input, preserves line structure (indentation, blank lines).
      */
     transform(input) {
+        const out = this.transformInternal(input);
+        // Hebrew: repair a fronted accusative marker the body-split heuristics can emit
+        // (`… את הוסף .x …` → `… הוסף את .x …`). Applied to the assembled output; idempotent
+        // across the internal recursion. See repairHebrewFrontedAccusative.
+        return this.targetProfile.code === 'he' ? repairHebrewFrontedAccusative(out) : out;
+    }
+    transformInternal(input) {
+        // Caret-scoped variable reads (`^name on <selector>`) carry a second,
+        // overloaded `on` that the splitter/event-parser would mistake for an event
+        // or command boundary — mangling `put ^count on #host into me`. Mask the
+        // ` on <selector>` scope behind an opaque token attached to `^name` so the
+        // command reorders as if the patient were a single value, then restore it.
+        // `on` is kept verbatim (the semantic caret-scope matcher accepts it by raw
+        // value across languages — passthrough-alignment).
+        const caret = maskCaretScopes(input);
+        if (caret) {
+            return restoreCaretScopes(this.transform(caret.masked), caret.scopes);
+        }
         const targetThen = getTargetThenKeyword(this.targetProfile.code);
+        // Inline JS blocks (`... js <raw js> end`) must be masked BEFORE any
+        // splitting/reordering: the body is raw JavaScript, not hyperscript, so it
+        // must never be tokenized, translated, or word-order reordered. (Single-line
+        // only here; multi-line js bodies are handled with the behavior work.)
+        if (!input.includes('\n')) {
+            const jsBlock = this.tryTransformJsBlock(input);
+            if (jsBlock !== null)
+                return jsBlock;
+            // Event handler whose body leads with a command-modifier
+            // (`on click async fetch …`, `on click once add …`): lift the modifier out
+            // so the real verb isn't mistaken for the action and the SOV reorder keeps
+            // the body patient-first (recoverable by the parser's SOV event extraction).
+            const eventModifier = this.tryTransformEventWithModifierBody(input);
+            if (eventModifier !== null)
+                return eventModifier;
+            // Event handler whose body is a block (`on <event> if/repeat/unless … end`):
+            // the block body must be reordered as a self-contained unit, not shredded
+            // across the event handler's role soup.
+            const eventBlock = this.tryTransformEventWithBlockBody(input);
+            if (eventBlock !== null)
+                return eventBlock;
+            // Event handler whose body is an un-terminated inline `unless` guard
+            // (`on click unless I match .disabled toggle .selected`): route the guard
+            // through the standalone block path so Hebrew's accusative marker lands on
+            // the body command, not the condition. Hebrew-only; null elsewhere.
+            const eventGuard = this.tryTransformEventWithUnlessGuard(input);
+            if (eventGuard !== null)
+                return eventGuard;
+        }
         // Check if input has multi-line structure worth preserving
         const hasMultiLineStructure = input.includes('\n');
         if (hasMultiLineStructure) {
@@ -8614,11 +9749,22 @@ class GrammarTransformer {
         if (block) {
             return this.transformBlock(block);
         }
+        // 0b. `set @attr to V on <scope>` (S1 tabs-aria): strip the trailing
+        //     `on <scope>`, transform the scope-less set normally, then re-insert
+        //     `on <scope>` where the semantic set patterns expect it.
+        const setScope = this.transformSetWithScope(input);
+        if (setScope !== null) {
+            return setScope;
+        }
         // 1. Parse into semantic roles
         const parsed = parseStatement(input, this.sourceProfile.code);
         if (!parsed) {
             return input; // Return unchanged if parsing fails
         }
+        // 1b. Re-assign a mis-marked primary argument (e.g. `wait`'s duration) off the
+        //     default `patient` role so the target doesn't emit a spurious object-marker.
+        //     Runs before translation while `action` is still the English keyword.
+        applyPrimaryRole(parsed, this.targetProfile);
         // 2. Translate individual words
         translateElements(parsed, this.sourceProfile.code, this.targetProfile.code);
         // 3. Find applicable rule
@@ -8640,6 +9786,411 @@ class GrammarTransformer {
         // 7. Join without markers (still use joinTokens for consistency)
         return joinTokens(reordered.map(e => e.translated || e.value));
     }
+    /**
+     * Detect and transform an inline JS block (`[on <event>] js <raw js> end`).
+     *
+     * The `js ... end` body is raw JavaScript: it must not be tokenized,
+     * translated, or word-order reordered. We mask the whole block with a single
+     * opaque placeholder, run the surrounding statement (the event-handler head,
+     * if any) through the normal reorder pipeline so the placeholder lands in the
+     * correct action position, then substitute the translated `js`/`end` keywords
+     * around the verbatim body.
+     *
+     * Returns `null` (fall through to the normal path) when there is no js block,
+     * no matching `end`, or trailing content after `end` (kept tight on purpose).
+     */
+    tryTransformJsBlock(input) {
+        const src = this.sourceProfile.code;
+        const dst = this.targetProfile.code;
+        // The `js` / `end` keyword forms in the SOURCE language.
+        const sourceJs = translateWord('js', 'en', src);
+        const sourceEnd = translateWord('end', 'en', src).toLowerCase();
+        const tokens = input.split(/\s+/).filter(t => t.length > 0);
+        // The js command token, optionally with a `(locals)` suffix: `js`, `js(me)`.
+        const escapedJs = sourceJs.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const jsRe = new RegExp(`^${escapedJs}(\\(.*\\))?$`, 'i');
+        const jsIdx = tokens.findIndex(t => jsRe.test(t));
+        if (jsIdx === -1)
+            return null;
+        // First `end` after the js keyword closes the block (raw JS never contains a
+        // bare hyperscript `end` token).
+        let endIdx = -1;
+        for (let i = jsIdx + 1; i < tokens.length; i++) {
+            if (tokens[i].toLowerCase() === sourceEnd) {
+                endIdx = i;
+                break;
+            }
+        }
+        if (endIdx === -1)
+            return null;
+        // Trailing content after `end` — leave for the normal path.
+        if (endIdx !== tokens.length - 1)
+            return null;
+        const jsToken = tokens[jsIdx];
+        const jsParen = jsToken.match(jsRe)?.[1] ?? '';
+        const jsKeywordRaw = jsParen ? jsToken.slice(0, jsToken.length - jsParen.length) : jsToken;
+        const body = tokens.slice(jsIdx + 1, endIdx).join(' ');
+        const targetJs = translateWord(jsKeywordRaw, src, dst) + jsParen;
+        const targetEnd = translateWord(tokens[endIdx], src, dst);
+        const replacement = [targetJs, body, targetEnd].filter(s => s.length > 0).join(' ');
+        const before = tokens.slice(0, jsIdx);
+        // Bare `js ... end` with no leading event-handler head: emit directly.
+        if (before.length === 0)
+            return replacement;
+        // Mask the block as one opaque action token, reorder the surrounding
+        // statement, then restore the verbatim block.
+        const placeholder = 'JSBLOCKPLACEHOLDER';
+        const reordered = this.transformSingle([...before, placeholder].join(' '));
+        if (!reordered.includes(placeholder))
+            return null; // unexpected — fall through
+        return reordered.replace(placeholder, replacement);
+    }
+    /**
+     * Transform an event handler whose body is a block command
+     * (`on <event> [from <src>] {if|repeat|unless|while|for} … end`).
+     *
+     * `parseEventHandler` would treat the block keyword as the action and sweep the
+     * condition/body into role values, then reorder them — shredding the block
+     * (`if event.shiftKey call submitAndContinue() end` → scattered tokens). Instead
+     * we mask the whole block as an opaque action placeholder, reorder the event
+     * head normally, transform the block as a self-contained unit, and restitch.
+     *
+     * Returns `null` (fall through) when the input isn't an event handler, has no
+     * block-keyword body, or has no closing `end`.
+     */
+    tryTransformEventWithBlockBody(input) {
+        const tokens = tokenize(input, this.sourceProfile);
+        if (tokens.length === 0)
+            return null;
+        if (!EVENT_KEYWORDS.has(tokens[0]?.toLowerCase()))
+            return null;
+        let blockIdx = -1;
+        for (let i = 1; i < tokens.length; i++) {
+            if (BLOCK_BODY_KEYWORDS.has(tokens[i].toLowerCase())) {
+                blockIdx = i;
+                break;
+            }
+        }
+        if (blockIdx <= 0)
+            return null;
+        // Only handle the explicitly-terminated form; un-terminated bodies
+        // (`on click unless X toggle Y`) keep the existing path.
+        if (tokens[tokens.length - 1].toLowerCase() !== 'end')
+            return null;
+        const eventHead = tokens.slice(0, blockIdx);
+        const blockTokens = tokens.slice(blockIdx);
+        // Event heads carrying a `from <source>` modifier (`on keydown[...] from
+        // .modal if … end`): for SVO/SOV targets, route them through this block-body
+        // path too — masking the block and emitting the event clause (incl. the
+        // translated `from <source>`, which `transformSingle` → `parseEventHandler`
+        // already reorders) first, then the transformed block. This keeps the if-block
+        // body from being shredded across the event handler's roles and properly
+        // translates its inner keywords (`in`/`focus`/`first`/positional); the old
+        // exclusion left them English and mangled the order (this is what cleared
+        // `focus-trap` in tr). VSO targets (ar, tl) are kept on the existing path:
+        // there the event-first emission with a `from`-source reorders incorrectly and
+        // regresses `focus-trap`/`window-keydown`, while the existing path already
+        // parses them. So the `from`-source exclusion is scoped to VSO only.
+        if (this.targetProfile.wordOrder === 'VSO' && eventHead.some(t => t.toLowerCase() === 'from')) {
+            return null;
+        }
+        const placeholder = 'EVENTBLOCKPLACEHOLDER';
+        const headOut = this.transformSingle([...eventHead, placeholder].join(' '));
+        if (!headOut.includes(placeholder))
+            return null;
+        const blockOut = this.transformBlockBody(blockTokens);
+        // Always emit the event clause first, then the block. An event handler's
+        // event is a leading delimiter, and the semantic parser only matches a
+        // block body when it follows the event — even in verb-first (VSO) languages
+        // whose normal command order would push the event to the end. So strip the
+        // placeholder out of the (possibly reordered) head and append the block,
+        // rather than substituting in place.
+        const eventClause = headOut.replace(placeholder, '').replace(/\s+/g, ' ').trim();
+        return [eventClause, blockOut].filter(s => s.length > 0).join(' ');
+    }
+    /**
+     * Transform an event handler whose body is an inline `unless` guard with NO
+     * `end` (`on <event> unless <cond> <body>` — the `unless-condition` shape).
+     *
+     * Object-marking SVO targets (he, zh). `parseEventHandler` reads `unless` as the
+     * action and sweeps the whole `<cond> <body>` tail into a single `patient` blob;
+     * the target then prefixes that blob with its object marker — Hebrew's accusative
+     * את (`… אלא את I match .disabled מתג .selected`) or Chinese's BA particle 把
+     * (`… 除非 把 I match .disabled 切换 .selected`) — and the inner toggle loses its
+     * own marker. The semantic parser can't recover the guard from that: the marker
+     * ahead of the condition blocks the `unless` pattern AND the now-markerless body
+     * command fails its object-marked toggle pattern, so the body collapses (`unless`
+     * dropped). Marker-less languages (de/it/ar/pl) tolerate the same role-blob and
+     * stay faithful, so this is an object-marker artifact, not a general parse gap.
+     *
+     * The standalone `unless <cond> <body>` path already produces the correct shape
+     * (`extractBlockStructure` → `transformBlock`: condition kept marker-free, body
+     * command keeps its marker — he `אלא I match .disabled מתג את .selected`, zh
+     * `除非 I match .disabled 切换 把 .selected`). So we split the event head off,
+     * transform the guard through that path, and emit the event clause first (he and
+     * zh are both SVO — event leads). Returns `null` (fall through) when the input
+     * isn't an object-marking event handler with an un-terminated inline `unless`
+     * guard.
+     */
+    tryTransformEventWithUnlessGuard(input) {
+        // SVO object-marking targets only — these front the unless tail with an object
+        // marker (he את / zh 把) that breaks the parse. Event-leads emission below
+        // assumes SVO, so SOV/VSO object-markers (ja/ko/tr/ar) are intentionally out.
+        if (!UNLESS_GUARD_OBJECT_MARKING_LOCALES.has(this.targetProfile.code))
+            return null;
+        const tokens = tokenize(input, this.sourceProfile);
+        if (tokens.length === 0)
+            return null;
+        if (!EVENT_KEYWORDS.has(tokens[0]?.toLowerCase()))
+            return null;
+        let guardIdx = -1;
+        for (let i = 1; i < tokens.length; i++) {
+            if (tokens[i].toLowerCase() === 'unless') {
+                guardIdx = i;
+                break;
+            }
+        }
+        if (guardIdx <= 0)
+            return null;
+        // The terminated form (`… unless … end`) is handled by
+        // tryTransformEventWithBlockBody's masking path; only take the inline guard.
+        if (tokens[tokens.length - 1].toLowerCase() === 'end')
+            return null;
+        const eventHead = tokens.slice(0, guardIdx);
+        const guard = tokens.slice(guardIdx).join(' ');
+        // `unless` is a BLOCK_HEAD keyword, so transform() routes the guard through
+        // extractBlockStructure → transformBlock (the standalone shape that parses).
+        const guardOut = this.transform(guard);
+        if (!guardOut)
+            return null;
+        const placeholder = 'EVENTGUARDPLACEHOLDER';
+        const headOut = this.transformSingle([...eventHead, placeholder].join(' '));
+        if (!headOut.includes(placeholder))
+            return null;
+        const eventClause = headOut.replace(placeholder, '').replace(/\s+/g, ' ').trim();
+        return [eventClause, guardOut].filter(s => s.length > 0).join(' ');
+    }
+    /**
+     * Transform an event handler whose body leads with a command-modifier
+     * (`on <event> [from <src>] {async|once|debounced [at N]|throttled [at N]} <body>`).
+     *
+     * `parseEventHandler` reads the first token after the event as the **action**, so
+     * a leading modifier is mistaken for the verb and the real verb (`fetch`/`add`) is
+     * swept into the patient. For SOV targets the reorder then surfaces that verb
+     * **first** (`取得 /api/data を クリック …`), and the semantic parser matches the
+     * leading `<verb> <patient>` with the low-priority `*-generated-verb-first`
+     * command pattern — returning a bare command and discarding the event + the rest
+     * of the body (degenerate parse).
+     *
+     * Instead, lift the modifier out, transform the modifier-free handler through the
+     * normal path (which keeps the body in canonical patient-first SOV order so the
+     * event sits mid-stream and the existing SOV event-extraction recovers it), then
+     * re-emit the modifier as a **leading English literal**. The semantic parser
+     * strips a leading `once`/`debounced`/`throttled` (`extractStandaloneModifiers`)
+     * and an `async` anywhere (`stripAsyncModifier`) before parsing, so the modifier
+     * is consumed as handler metadata rather than shadowing the body.
+     *
+     * Returns `null` (fall through) when the input isn't an event handler or the body
+     * doesn't lead with a modifier — leaving simple/Mode-B handlers byte-identical.
+     */
+    tryTransformEventWithModifierBody(input) {
+        // The verb-first degenerate parse this works around is specific to SOV
+        // reorder: only there does a leading modifier displace the patient-first
+        // order and surface the verb first. SVO/VSO/V2/other targets keep the body
+        // in an order the parser already handles, so leave them byte-identical.
+        if (this.targetProfile.wordOrder !== 'SOV')
+            return null;
+        const tokens = tokenize(input, this.sourceProfile);
+        if (tokens.length === 0)
+            return null;
+        if (!EVENT_KEYWORDS.has(tokens[0]?.toLowerCase()))
+            return null;
+        // Walk past the event clause head: event keyword, event token, any
+        // `or`-conjoined events, and an optional `from <source>` modifier — mirroring
+        // parseEventHandler's head parsing — to find where the body begins.
+        let i = 1; // past the event keyword
+        if (!tokens[i])
+            return null;
+        i++; // past the event token
+        while (tokens[i] && EVENT_CONJUNCTIONS.has(tokens[i].toLowerCase()) && tokens[i + 1]) {
+            i += 2;
+        }
+        if (tokens[i]?.toLowerCase() === 'from' && tokens[i + 1]) {
+            i++; // skip 'from'
+            // Collect source tokens until a command verb or a body modifier.
+            while (tokens[i] &&
+                !ENGLISH_COMMANDS.has(tokens[i].toLowerCase()) &&
+                !BODY_MODIFIER_KEYWORDS.has(tokens[i].toLowerCase())) {
+                i++;
+            }
+        }
+        const modWord = tokens[i]?.toLowerCase();
+        if (!modWord || !BODY_MODIFIER_KEYWORDS.has(modWord))
+            return null;
+        // Consume the modifier phrase. `debounced`/`throttled` may carry an optional
+        // `at <duration>` (or a bare duration). `async`/`once` are single tokens.
+        const modStart = i;
+        let modEnd = i + 1;
+        if (modWord !== 'async' && modWord !== 'once') {
+            if (tokens[modEnd]?.toLowerCase() === 'at')
+                modEnd++;
+            if (tokens[modEnd] && /^\d+(ms|s|m)?$/.test(tokens[modEnd]))
+                modEnd++;
+        }
+        const modifierPhrase = tokens.slice(modStart, modEnd).join(' ');
+        const rebuilt = [...tokens.slice(0, modStart), ...tokens.slice(modEnd)].join(' ');
+        // A handler with only a modifier and no body has nothing to keep patient-first.
+        if (tokens.length - (modEnd - modStart) <= 2)
+            return null;
+        // Re-run the full transform on the modifier-free handler so then-chains and
+        // juxtaposed bodies route through the existing (working) paths. The rebuilt
+        // input no longer leads with a modifier, so this never re-enters here.
+        const bodyOut = this.transform(rebuilt);
+        return [modifierPhrase, bodyOut].filter(s => s.length > 0).join(' ');
+    }
+    /**
+     * Transform a `set <stuff> on <scope>` clause (S1 tabs-aria). The trailing
+     * `on <scope>` is the element(s) the attribute is set on — kept attached by
+     * splitOnCommandBoundaries. The semantic parser captures it as a `scope` role
+     * via the passthrough literal `on` (setSchema's scope markerOverride is `on`
+     * in every language), so `on` is emitted verbatim and only the scope *value*
+     * is translated (selectors pass through; `me`/`it`/`you` translate to the
+     * native reference, which the parser also accepts).
+     *
+     * Positioning matches where the set patterns expect the scope: at the clause
+     * end for verb-first orders (SVO/VSO), and immediately before the clause-final
+     * verb for SOV (the generated SOV pattern is `{dest} {patient} on {scope}
+     * {verb}`). Returns null (fall through) when there is no trailing `on <scope>`.
+     *
+     * Source is English in the sync-translations pipeline, so the `set` verb and
+     * `on` marker are matched as English literals.
+     */
+    transformSetWithScope(input) {
+        const src = this.sourceProfile.code;
+        const dst = this.targetProfile.code;
+        const m = input.match(/^(.*\bset\b.*\S)\s+on\s+([#.<@[]\S*|me|it|you)\s*$/i);
+        if (!m)
+            return null;
+        const head = m[1];
+        const scopeRaw = m[2];
+        // Transform the scope-less clause via the normal path; `head` no longer ends
+        // in `on <scope>`, so this never re-enters transformSetWithScope.
+        const headOut = this.transformSingle(head);
+        const scopeT = /^[#.<@[]/.test(scopeRaw) ? scopeRaw : translateWord(scopeRaw, src, dst);
+        // SOV needs the scope positioned per how the semantic set patterns match:
+        //  - Event-handler set (`on <event> set …`): the dest-first SOV event-handler
+        //    pattern is verb-MEDIAL and carries an optional trailing `[on {scope}]`,
+        //    so append the scope at the clause end.
+        //  - Standalone then-clause set: SOV emits verb-MEDIAL (`{dest} {verb}
+        //    {patient}`), but the only command set pattern with scope is verb-LAST
+        //    (`{dest} {patient} on {scope} {verb}`). Move the medial verb to the end
+        //    and place `on {scope}` before it, so the generated command pattern matches.
+        if (this.targetProfile.wordOrder === 'SOV') {
+            const verb = translateWord('set', 'en', dst);
+            const firstTok = input.trim().split(/\s+/)[0]?.toLowerCase();
+            const isEventHandler = !!firstTok && EVENT_KEYWORDS.has(firstTok);
+            const toks = headOut.split(/\s+/).filter(Boolean);
+            if (!isEventHandler) {
+                // Standalone then-clause set: SOV emits verb-MEDIAL; move the verb to the
+                // end and place `on {scope}` before it so the verb-last command set
+                // pattern (scope before verb) matches.
+                const vIdx = toks.indexOf(verb);
+                if (vIdx >= 0) {
+                    toks.splice(vIdx, 1);
+                    toks.push('on', scopeT, verb);
+                    return toks.join(' ');
+                }
+            }
+            else if (toks.length > 0 && toks[toks.length - 1] === verb) {
+                // Event-handler set whose verb is clause-final (e.g. qu
+                // `{dest} ta {patient} man {event} pi {verb}`): the parser extracts the
+                // event and matches the body as a verb-last command, so the scope must
+                // sit before the verb. Verb-MEDIAL SOV event handlers (ja/ko/tr/bn/hi)
+                // fall through to the append branch, where their fused event-handler set
+                // pattern carries the trailing `[on {scope}]` group.
+                toks.splice(toks.length - 1, 0, 'on', scopeT);
+                return toks.join(' ');
+            }
+            return `${headOut} on ${scopeT}`;
+        }
+        // Verb-first (SVO/VSO/V2): append `on <scope>` at the clause end, which the
+        // trailing `[on {scope}]` group on the set patterns matches.
+        return `${headOut} on ${scopeT}`;
+    }
+    /**
+     * Transform a self-contained block command (`{head} {clause?} {body} {end}`),
+     * where head ∈ {if, repeat, unless, …}. The clause (condition / `until event …`)
+     * runs up to the first command verb and is translated word-by-word; the body is
+     * recursively transformed (so its inner commands reorder for the target); the
+     * head/tail keywords are translated. The block is never word-order reordered as
+     * a whole — delimiters stay at the edges regardless of target word order.
+     */
+    transformBlockBody(blockTokens) {
+        const src = this.sourceProfile.code;
+        const dst = this.targetProfile.code;
+        const head = blockTokens[0];
+        const hasEnd = blockTokens[blockTokens.length - 1]?.toLowerCase() === 'end';
+        const tail = hasEnd ? blockTokens[blockTokens.length - 1] : '';
+        const inner = blockTokens.slice(1, hasEnd ? -1 : undefined);
+        // Skip predicate-adjective positions (`… is empty`): the adjective is
+        // part of the condition clause, not the body's first verb — cutting there
+        // displaced it into the next command's argument zone (empty ×8 bn/hi/tr).
+        const commands = getCommandKeywordsForLocale(src);
+        const copulas = getCopulasForLocale(src);
+        let bodyStart = inner.findIndex((t, i) => commands.has(t.toLowerCase()) && !isPredicateAdjectivePosition(inner, i, copulas));
+        if (bodyStart < 0)
+            bodyStart = inner.length;
+        const clause = inner.slice(0, bodyStart).join(' ');
+        const bodyTokens = inner.slice(bodyStart);
+        const headT = translateWord(head, src, dst);
+        const tailT = tail ? translateWord(tail, src, dst) : '';
+        const clauseT = clause ? translateMultiWordValue(clause, src, dst) : '';
+        const bodyT = this.transformConditionalBody(bodyTokens);
+        return [headT, clauseT, bodyT, tailT].filter(s => s.length > 0).join(' ');
+    }
+    /**
+     * Transform an `if`/`unless` block body, splitting it at a top-level `else` into
+     * a then-branch and an else-branch so each is reordered as a self-contained unit
+     * and the `else` keyword itself is translated. Without this, the body is reordered
+     * as one stream: `else` rides along glued to the preceding clause (and, when that
+     * clause begins with a selector, is marked a selector and left *untranslated*),
+     * and a spurious `then` is inserted around it — both of which break the target
+     * text and the downstream parse. The split is depth-aware so an `else` belonging
+     * to a nested block is not mistaken for this block's separator. Bodies without an
+     * `else` transform exactly as before.
+     */
+    transformConditionalBody(bodyTokens) {
+        const src = this.sourceProfile.code;
+        const dst = this.targetProfile.code;
+        const sourceElse = translateWord('else', 'en', src).toLowerCase();
+        let depth = 0;
+        let elseIdx = -1;
+        for (let i = 0; i < bodyTokens.length; i++) {
+            const t = bodyTokens[i].toLowerCase();
+            if (BLOCK_BODY_KEYWORDS.has(t))
+                depth++;
+            else if (t === 'end' && depth > 0)
+                depth--;
+            else if (t === sourceElse && depth === 0) {
+                elseIdx = i;
+                break;
+            }
+        }
+        if (elseIdx === -1) {
+            const body = bodyTokens.join(' ');
+            return body ? this.transform(body) : '';
+        }
+        const thenBranch = bodyTokens.slice(0, elseIdx).join(' ');
+        const elseBranch = bodyTokens.slice(elseIdx + 1).join(' ');
+        const elseT = translateWord(bodyTokens[elseIdx], src, dst);
+        return [
+            thenBranch ? this.transform(thenBranch) : '',
+            elseT,
+            elseBranch ? this.transform(elseBranch) : '',
+        ]
+            .filter(s => s.length > 0)
+            .join(' ');
+    }
     /**
      * Translate a reactive block by translating the head/tail/connector
      * via the dictionary, recursively transforming the body through the
@@ -8806,5 +10357,5 @@ const examples = {
     },
 };
 
-export { ENGLISH_COMMANDS, ENGLISH_KEYWORDS, GrammarTransformer, LANGUAGE_FAMILY_DEFAULTS, LocaleManager, UNIVERSAL_ENGLISH_KEYWORDS, UNIVERSAL_PATTERNS, ar$1 as ar, ar$1 as arDictionary, arKeywords, arabicProfile, bn$1 as bn, bn$1 as bnDictionary, bnKeywords, chineseProfile, createEnglishProvider, createKeywordProvider, de$1 as de, de$1 as deDictionary, deKeywords, detectBrowserLocale, directMappings, en$1 as en, englishProfile, es$1 as es, es$1 as esDictionary, esKeywords, fr$1 as fr, fr$1 as frDictionary, frKeywords, frenchProfile, germanProfile, getDirectMapping, getProfile, getSupportedDirectPairs, getSupportedLocales, examples as grammarExamples, hasDirectMapping, he$1 as he, he$1 as heDictionary, heKeywords, hebrewProfile, hindiDictionary as hiDictionary, hiKeywords, hindiDictionary, id$1 as id, id$1 as idDictionary, idKeywords, indonesianProfile, insertMarkers, it$1 as it, it$1 as itDictionary, itKeywords, ja$1 as ja, ja$1 as jaDictionary, jaKeywords, japaneseProfile, joinTokens, ko$1 as ko, ko$1 as koDictionary, koKeywords, koreanProfile, ms$1 as ms, ms$1 as msDictionary, msKeywords, parseStatement, pl$1 as pl, pl$1 as plDictionary, plKeywords, portugueseProfile, profiles, pt$1 as pt, pt$1 as ptDictionary, ptKeywords, qu$1 as qu, qu$1 as quDictionary, quKeywords, quechuaProfile, reorderRoles, russianDictionary as ruDictionary, ruKeywords, russianDictionary, spanishProfile, sw$1 as sw, sw$1 as swDictionary, swKeywords, swahiliProfile, th$1 as th, th$1 as thDictionary, thKeywords, tl$1 as tl, tl$1 as tlDictionary, tlKeywords, toEnglish, toLocale, tr$1 as tr, tr$1 as trDictionary, trKeywords, transformStatement, translate, translateWordDirect, turkishProfile, ukrainianDictionary as ukDictionary, ukKeywords, ukrainianDictionary, vi$1 as vi, vi$1 as viDictionary, viKeywords, zh$1 as zh, zh$1 as zhDictionary, zhKeywords };
+export { ENGLISH_COMMANDS, ENGLISH_KEYWORDS, GrammarTransformer, LANGUAGE_FAMILY_DEFAULTS, LocaleManager, UNIVERSAL_ENGLISH_KEYWORDS, UNIVERSAL_PATTERNS, ar$1 as ar, ar$1 as arDictionary, arKeywords, arabicProfile, bn$1 as bn, bn$1 as bnDictionary, bnKeywords, chineseProfile, createEnglishProvider, createKeywordProvider, de$1 as de, de$1 as deDictionary, deKeywords, detectBrowserLocale, directMappings, en$1 as en, englishProfile, es$1 as es, es$1 as esDictionary, esKeywords, fr$1 as fr, fr$1 as frDictionary, frKeywords, frenchProfile, germanProfile, getDirectMapping, getProfile, getSupportedDirectPairs, getSupportedLocales, examples as grammarExamples, hasDirectMapping, he$1 as he, he$1 as heDictionary, heKeywords, hebrewProfile, hindiDictionary as hiDictionary, hiKeywords, hindiDictionary, id$1 as id, id$1 as idDictionary, idKeywords, indonesianProfile, insertMarkers, it$1 as it, it$1 as itDictionary, itKeywords, ja$1 as ja, ja$1 as jaDictionary, jaKeywords, japaneseProfile, joinTokens, ko$1 as ko, ko$1 as koDictionary, koKeywords, koreanProfile, malayProfile, ms$1 as ms, ms$1 as msDictionary, msKeywords, parseStatement, pl$1 as pl, pl$1 as plDictionary, plKeywords, portugueseProfile, profiles, pt$1 as pt, pt$1 as ptDictionary, ptKeywords, qu$1 as qu, qu$1 as quDictionary, quKeywords, quechuaProfile, reorderRoles, russianDictionary as ruDictionary, ruKeywords, russianDictionary, spanishProfile, sw$1 as sw, sw$1 as swDictionary, swKeywords, swahiliProfile, th$1 as th, th$1 as thDictionary, thKeywords, tl$1 as tl, tl$1 as tlDictionary, tlKeywords, toEnglish, toLocale, tr$1 as tr, tr$1 as trDictionary, trKeywords, transformStatement, translate, translateWordDirect, turkishProfile, ukrainianDictionary as ukDictionary, ukKeywords, ukrainianDictionary, vi$1 as vi, vi$1 as viDictionary, viKeywords, zh$1 as zh, zh$1 as zhDictionary, zhKeywords };
 //# sourceMappingURL=lokascript-i18n.mjs.map