@lokascript/i18n 2.7.2 → 2.9.0

package/src/grammar/grammar.test.ts

@@ -2510,3 +2510,155 @@ describe('qu fused (no-underscore) empty/null value word (chusaq)', () => {
     expect(out.indexOf('chusaq')).toBeLessThan(out.indexOf('.error'));
   });
 });
+
+// =============================================================================
+// SOV reorder stranding (transformer-rendering arc)
+// =============================================================================
+//
+// Three rendering defects, one family (docs-internal/HANDOFF_transformer-rendering.md):
+// (a) `wait for X or Y from Z` rendered verb-first (tr) / verb-medial (qu) —
+//     reorderRoles' safety-net appended roles missing from canonicalOrder
+//     AFTER the verb, stranding the or-run/from-phrase outside the clause;
+// (b) `repeat until event E from S` postposed the from-phrase after the verb;
+// (c) a trailing block terminator (`… wait 200ms end` fragments from the
+//     then-splitter) was swept into the open role's VALUE and rendered inside
+//     the phrase instead of after the verb.
+// Fixed by extending tr/qu/bn canonicalOrder to full verb-final role orders
+// and stripping/re-appending the stranded terminator in transformSingle.
+
+describe('SOV reorder stranding (transformer-rendering arc)', () => {
+  it('[tr] wait + or-run + from-phrase renders verb-final, from-phrase in-clause', () => {
+    const out = new GrammarTransformer('en', 'tr').transform(
+      'wait for pointermove(clientY) or pointerup(clientY) from document'
+    );
+    expect(out).toContain('veya');
+    expect(out.trim().endsWith('bekle')).toBe(true);
+    expect(out.indexOf('belge den')).toBeGreaterThanOrEqual(0);
+    expect(out.indexOf('belge den')).toBeLessThan(out.indexOf('bekle'));
+  });
+
+  it('[qu] wait + or-run + from-phrase renders verb-final, from-phrase in-clause', () => {
+    const out = new GrammarTransformer('en', 'qu').transform(
+      'wait for pointermove(clientY) or pointerup(clientY) from document'
+    );
+    expect(out).toContain('utaq');
+    expect(out.trim().endsWith('suyay')).toBe(true);
+    expect(out.indexOf('qillqa manta')).toBeGreaterThanOrEqual(0);
+    expect(out.indexOf('qillqa manta')).toBeLessThan(out.indexOf('pointermove'));
+  });
+
+  it('[tr] repeat-until-event keeps the from-phrase before the verb', () => {
+    const out = new GrammarTransformer('en', 'tr').transform(
+      'repeat until event pointerup from document'
+    );
+    expect(out.trim().endsWith('tekrarla')).toBe(true);
+    expect(out.indexOf('belge den')).toBeGreaterThanOrEqual(0);
+    expect(out.indexOf('belge den')).toBeLessThan(out.indexOf('tekrarla'));
+  });
+
+  it('[bn] trailing-end fragment renders the terminator after the verb', () => {
+    // `then`-split fragment of `… then wait 200ms end` (repeat-while body).
+    const out = new GrammarTransformer('en', 'bn').transform('wait 200ms end');
+    expect(out.trim()).toBe('200ms কে অপেক্ষা শেষ');
+    expect(out).not.toContain('শেষ কে'); // terminator no longer inside the object phrase
+  });
+
+  it('[qu] inline-if set keeps its verb-final tail before the terminator', () => {
+    const out = new GrammarTransformer('en', 'qu').transform(
+      'if newWidth < minWidth then set newWidth to minWidth end'
+    );
+    expect(out).toMatch(/man churanay tukuy\s*$/);
+  });
+
+  it('[tr] trailing-end set fragment renders verb-final with trailing terminator', () => {
+    // Previously the set-to rule's end-guard predicate skipped verb-final
+    // reorder for these fragments; with the terminator stripped first, the
+    // rule applies and the terminator follows the verb.
+    const out = new GrammarTransformer('en', 'tr').transform('set dragClass to "sorting" end');
+    expect(out.trim()).toBe('dragClass i "sorting" e ayarla son');
+  });
+
+  const draggableWait =
+    'wait for pointermove(clientX, clientY) or pointerup(clientX, clientY) from document';
+  it('[tr] draggable-shaped wait (clientX, clientY) is verb-final', () => {
+    const out = new GrammarTransformer('en', 'tr').transform(draggableWait);
+    expect(out.trim().endsWith('bekle')).toBe(true);
+    expect(out.indexOf('belge den')).toBeLessThan(out.indexOf('bekle'));
+  });
+  it('[qu] draggable-shaped wait (clientX, clientY) is verb-final', () => {
+    const out = new GrammarTransformer('en', 'qu').transform(draggableWait);
+    expect(out.trim().endsWith('suyay')).toBe(true);
+    expect(out.indexOf('qillqa manta')).toBeLessThan(out.indexOf('pointermove'));
+  });
+});
+
+// The form-submit-prevent head fuses TWO juxtaposed commands (`halt the event
+// call validateForm()`); parseEventHandler sweeps both into one patient blob
+// and the SOV patient-first reorder fronted it whole — halt's operand stranded
+// clause-initial, call's operand riding with it (tr bound validateForm() to
+// halt and the event to call). sovHaltCallFusedRule splits the blob at the
+// language's call verb and emits both commands verb-final, joined by the
+// then-connective (R1 deferred-tail Family H,
+// docs-internal/HANDOFF_r1-deferred-tail.md).
+describe('SOV fused halt+call heads render both commands verb-final (Family H)', () => {
+  const src =
+    'on submit halt the event call validateForm() if result is false log "Invalid form" end';
+  const EXPECT: Array<[string, string]> = [
+    ['ja', 'the イベント を 送信 で 停止 それから validateForm() を 呼び出し'],
+    ['ko', 'the 이벤트 를 제출 할 때 정지 그러면 validateForm() 를 호출'],
+    // Batch 3: tr submit event word gönder→gönderme (gönder is the send verb — captured event "send")
+    ['tr', 'the olay i gönderme de durdur ardından validateForm() i çağır'],
+    ['bn', 'the ঘটনা কে জমা এ থামুন তারপর validateForm() কে কল'],
+    ['hi', 'the घटना को जमा पर रोकें फिर validateForm() को कॉल'],
+    // Batch 3: qu submit event word kachay→apaykachay (kachay is the send verb — captured "send" in this slot)
+    ['qu', 'the ruway ta apaykachay pi sayay chayqa validateForm() ta qayay'],
+  ];
+  for (const [lang, head] of EXPECT) {
+    it(`[${lang}] halt keeps its operand adjacent + verb-final; call follows the connective`, () => {
+      const out = new GrammarTransformer('en', lang).transform(src);
+      expect(out.startsWith(head)).toBe(true);
+    });
+  }
+
+  it('[ja] a plain `halt the event` handler keeps its default render (rule stands down)', () => {
+    const out = new GrammarTransformer('en', 'ja').transform('on submit halt the event');
+    expect(out.trim()).toBe('the イベント を 送信 で 停止');
+  });
+
+  it('[tr] a call-only handler keeps its default render (no halt — rule stands down)', () => {
+    const out = new GrammarTransformer('en', 'tr').transform('on click call myFunction()');
+    expect(out.trim()).toBe('myFunction() i tıklama de çağır');
+  });
+});
+
+// SOV renders emit nothing between an if-condition's tail and a POSITIONAL-
+// headed branch operand (`… .modal 最初 <button/> …`), and the semantic fold's
+// command-start detection can't see that shape — the condition swallowed the
+// focus operand's head (focus-trap, ja/ko/qu). transformBlockBody now emits
+// the target's then-connective at the clause/body seam, gated to exactly the
+// blind shape (R1 deferred-tail Family G).
+describe('SOV if-blocks get a then-connective before a positional branch head (Family G)', () => {
+  const src =
+    'on keydown[key=="Tab"] from .modal if target matches last <button/> in .modal focus first <button/> in .modal halt end';
+  const SEAM: Array<[string, string]> = [
+    ['ja', '.modal それから 最初'],
+    ['ko', '.modal 그러면 첫번째'],
+    ['qu', '.modal chayqa ñawpaq'],
+    ['tr', '.modal ardından ilk'],
+    ['bn', '.modal তারপর প্রথম'],
+    ['hi', '.modal फिर पहला'],
+  ];
+  for (const [lang, seam] of SEAM) {
+    it(`[${lang}] focus-trap renders the connective at the condition/branch seam`, () => {
+      const out = new GrammarTransformer('en', lang).transform(src);
+      expect(out).toContain(seam);
+    });
+  }
+
+  it('[qu] a non-positional branch head gains no connective (form-submit if unchanged)', () => {
+    const out = new GrammarTransformer('en', 'qu').transform(
+      'on submit halt the event call validateForm() if result is false log "Invalid form" end'
+    );
+    expect(out).toContain('llulla "Invalid form" ta qillqakuy');
+  });
+});

package/src/grammar/profiles/index.ts

@@ -6,7 +6,7 @@
  * language-specific markers and rules.
  */
 
-import type { LanguageProfile, SemanticRole } from '../types';
+import type { GrammarRule, LanguageProfile, SemanticRole } from '../types';
 import { reorderRoles, insertMarkers } from '../types';
 
 // =============================================================================
@@ -47,6 +47,167 @@ export const englishProfile: LanguageProfile = {
   ],
 };
 
+// =============================================================================
+// Shared SOV rule factory — fused `halt the event call fn()` heads (Family H,
+// docs-internal/HANDOFF_r1-deferred-tail.md)
+// =============================================================================
+
+/**
+ * The form-submit-prevent head fuses TWO juxtaposed commands (`on submit halt
+ * the event call validateForm()`): parseEventHandler reads `halt` as the
+ * action and sweeps `the event call validateForm()` into ONE patient blob, so
+ * the SOV patient-first reorder fronts the whole blob — halt's operand lands
+ * clause-initial far from its verb, and call's operand rides inside the blob
+ * (tr bound validateForm() to halt and the event to call). No roleOrder can
+ * fix a single-blob patient; this custom render splits the blob at the
+ * language's call verb and emits both commands verb-final, joined by the
+ * then-connective (the boundary the semantic compound-splitter already
+ * respects — the event-debounce geometry):
+ *
+ *   `<halt-operand> <pm> <event> <em> <halt-verb> <conn> <call-args> <pm> <call-verb>`
+ *
+ * The trailing EVENTBLOCKPLACEHOLDER (tryTransformEventWithBlockBody's mask
+ * for an `if … end` tail) is re-emitted clause-final so the caller's
+ * strip-and-append keeps working.
+ */
+function sovHaltCallFusedRule(cfg: {
+  callVerb: string; // the dictionary's call rendering — the blob split point
+  patientMarker: string;
+  eventMarker: string;
+  connective: string;
+}): GrammarRule {
+  return {
+    name: 'halt-call-fused-verb-final',
+    description: 'Split the swept `halt <operand> call <args>` blob; both verbs clause-final',
+    priority: 95,
+    match: {
+      commands: ['halt'],
+      requiredRoles: ['action', 'event', 'patient'],
+      // Only the juxtaposed-call blob: a plain `halt`/`halt the event` handler
+      // keeps its default render. The translated call verb must be present to
+      // split on — if the dictionary emission drifts, the rule stands down
+      // rather than emitting a mangled clause.
+      predicate: parsed => {
+        const p = parsed.roles.get('patient');
+        return (
+          !!p && /\bcall\b/.test(p.value) && !!p.translated && p.translated.includes(cfg.callVerb)
+        );
+      },
+    },
+    transform: {
+      roleOrder: [], // unused — custom takes over
+      custom: parsed => {
+        const p = parsed.roles.get('patient')!;
+        const ev = parsed.roles.get('event')!;
+        const act = parsed.roles.get('action')!;
+        let blob = (p.translated ?? p.value).trim();
+        const PH = 'EVENTBLOCKPLACEHOLDER';
+        let tail = '';
+        if (blob.endsWith(PH)) {
+          blob = blob.slice(0, -PH.length).trim();
+          tail = ` ${PH}`;
+        }
+        const at = blob.indexOf(cfg.callVerb);
+        const haltOperand = blob.slice(0, at).trim();
+        const callArgs = blob.slice(at + cfg.callVerb.length).trim();
+        return (
+          [
+            haltOperand,
+            cfg.patientMarker,
+            ev.translated ?? ev.value,
+            cfg.eventMarker,
+            act.translated ?? act.value,
+            cfg.connective,
+            callArgs,
+            cfg.patientMarker,
+            cfg.callVerb,
+          ].join(' ') + tail
+        );
+      },
+    },
+  };
+}
+
+// =============================================================================
+// Shared SOV rule factory — pick range rows (`pick characters 0 to 5 of #note`,
+// docs-internal/HANDOFF_pick-text-range-arc3.md)
+// =============================================================================
+
+/**
+ * The canonical pick range row decomposes in parseStatement/parseEventHandler as
+ * patient=`characters 0` + destination=`5 of #note` (the range's `to` reads as a
+ * destination marker), so the default SOV reorder scatters the range across the
+ * clause — ja emitted `文字 0 を クリック で 選択 5 の #note に` with the `5`
+ * stranded after the verb, unparseable in every SOV language. No roleOrder can
+ * reunite a range split across two roles; this custom render reassembles the
+ * canonical surface and emits the SOV convention shape (big patient phrase
+ * first, verb final):
+ *
+ *   `<root> <gen> <unit> <a> <sep> <b> <pm> [<event> <em>] <verb>`
+ *
+ * e.g. ja `#note の 文字 0 から 5 を クリック で 選択`. The paired semantic
+ * pick pattern (patterns/pick.ts VERB_FINAL_SPECS) parses exactly this shape
+ * back, with the range fold normalizing `<a> <sep> <b>` to English `a to b` —
+ * the two sides co-evolve per the i18n-renders-semantic-patterns-coevolve
+ * lesson; change one and you must re-probe the other.
+ *
+ * Gated tight to the numeric-endpoint corpus shape (`<unit> <int>` patient +
+ * `<int> of <root>` destination); word endpoints (`start`/`end`), modes
+ * (`inclusive`) and anything else fall through to the default render unchanged.
+ */
+function sovPickRangeRule(cfg: {
+  /** Genitive joiner between the root and the unit word (ja `の`, hi `का`). */
+  genitive: string;
+  /** Range separator between the two endpoints (ja `から`, hi `से`). */
+  rangeSep: string;
+  /** Patient/object marker after the range (ja `を`, hi `को`). */
+  patientMarker: string;
+  /** Event marker after the event word (ja `で`, hi `पर`). */
+  eventMarker: string;
+}): GrammarRule {
+  return {
+    name: 'pick-range-verb-final',
+    description: 'Reassemble the pick range (unit + endpoints + root) adjacent, verb-final',
+    priority: 95,
+    match: {
+      commands: ['pick'],
+      requiredRoles: ['action', 'patient', 'destination'],
+      predicate: parsed => {
+        const p = parsed.roles.get('patient');
+        const d = parsed.roles.get('destination');
+        return (
+          !!p &&
+          !!d &&
+          /^\S+\s+\d+$/.test(p.value.trim()) &&
+          /^\d+\s+of\s+\S+$/.test(d.value.trim())
+        );
+      },
+    },
+    transform: {
+      roleOrder: [], // unused — custom takes over
+      custom: parsed => {
+        const p = parsed.roles.get('patient')!;
+        const d = parsed.roles.get('destination')!;
+        const act = parsed.roles.get('action')!;
+        const ev = parsed.roles.get('event');
+        // Unit word from the TRANSLATED patient (`文字 0` → `文字`); endpoints
+        // and root from the UNTRANSLATED values — integers and selectors are
+        // language-invariant by construction (the R3 rule).
+        const pParts = (p.translated ?? p.value).trim().split(/\s+/);
+        const a = pParts[pParts.length - 1]!;
+        const unit = pParts.slice(0, -1).join(' ');
+        const dMatch = d.value.trim().match(/^(\d+)\s+of\s+(\S+)$/)!;
+        const b = dMatch[1]!;
+        const root = dMatch[2]!;
+        const verb = act.translated ?? act.value;
+        const head = [root, cfg.genitive, unit, a, cfg.rangeSep, b, cfg.patientMarker];
+        const eventPart = ev ? [ev.translated ?? ev.value, cfg.eventMarker] : [];
+        return [...head, ...eventPart, verb].join(' ');
+      },
+    },
+  };
+}
+
 // =============================================================================
 // Japanese (SOV, Postpositions)
 // =============================================================================
@@ -140,6 +301,20 @@ export const japaneseProfile: LanguageProfile = {
         insertMarkers: true,
       },
     },
+    // the イベント を 送信 で 停止 それから validateForm() を 呼び出し
+    sovHaltCallFusedRule({
+      callVerb: '呼び出し',
+      patientMarker: 'を',
+      eventMarker: 'で',
+      connective: 'それから',
+    }),
+    // #note の 文字 0 から 5 を クリック で 選択
+    sovPickRangeRule({
+      genitive: 'の',
+      rangeSep: 'から',
+      patientMarker: 'を',
+      eventMarker: 'で',
+    }),
   ],
 };
 
@@ -248,6 +423,20 @@ export const koreanProfile: LanguageProfile = {
         insertMarkers: true,
       },
     },
+    // the 이벤트 를 제출 할 때 정지 그러면 validateForm() 를 호출
+    sovHaltCallFusedRule({
+      callVerb: '호출',
+      patientMarker: '를',
+      eventMarker: '할 때',
+      connective: '그러면',
+    }),
+    // #note 의 문자 0 부터 5 를 클릭 할 때 선택
+    sovPickRangeRule({
+      genitive: '의',
+      rangeSep: '부터',
+      patientMarker: '를',
+      eventMarker: '할 때',
+    }),
   ],
 };
 
@@ -420,6 +609,12 @@ export const turkishProfile: LanguageProfile = {
   morphology: 'agglutinative',
   direction: 'ltr',
 
+  // NOTE: roles absent from this order are safety-net-appended AFTER the verb
+  // by reorderRoles. That stranding is what the semantic parser's generated
+  // patterns + reclaim tolerances were built around, so extending this order
+  // wholesale re-renders (and breaks) the whole tr corpus — fix individual
+  // defective shapes with per-command `rules` below instead (see the
+  // wait/repeat-until rules from the transformer-rendering arc).
   canonicalOrder: ['patient', 'event', 'action'],
 
   markers: [
@@ -516,6 +711,58 @@ export const turkishProfile: LanguageProfile = {
         insertMarkers: true,
       },
     },
+    {
+      name: 'wait-oblique-verb-final',
+      description: "Keep wait's from-phrase and or-run inside the clause, verb-final",
+      priority: 90,
+      match: {
+        commands: ['wait', 'bekle'],
+        // Only the multi-argument form (`wait for X or Y from Z`) strands:
+        // without this rule the safety-net appends duration+source AFTER the
+        // verb (`bekle … belge den`), and the stranded from-phrase is captured
+        // by the NEXT statement as a junk trigger event (behavior-sortable R3).
+        requiredRoles: ['action', 'duration', 'source'],
+        // Never reorder a fused single-line handler — its event must stay put.
+        predicate: parsed => !parsed.roles.has('event'),
+      },
+      transform: {
+        // belge den pointermove(clientY) veya pointerup(clientY) bekle
+        roleOrder: ['patient', 'source', 'duration', 'action'],
+        insertMarkers: true,
+      },
+    },
+    {
+      name: 'repeat-until-event-verb-final',
+      description: "Keep repeat-until-event's from-phrase before the verb",
+      priority: 90,
+      match: {
+        commands: ['repeat', 'tekrarla'],
+        requiredRoles: ['action', 'patient', 'source'],
+        // Gate to the until-event head; `repeat for item in .items` also
+        // carries patient+source and must keep its (parseable) default order.
+        predicate: parsed => /^repeat\s+until\s+event\b/i.test((parsed.original ?? '').trim()),
+      },
+      transform: {
+        // kadar olay pointerup i belge den tekrarla — matched semantic-side by
+        // repeat-tr-until-head-verb-final.
+        roleOrder: ['patient', 'source', 'action'],
+        insertMarkers: true,
+      },
+    },
+    // the olay i gönder de durdur ardından validateForm() i çağır
+    sovHaltCallFusedRule({
+      callVerb: 'çağır',
+      patientMarker: 'i',
+      eventMarker: 'de',
+      connective: 'ardından',
+    }),
+    // #note nin karakterler 0 ile 5 i tıklama de seç
+    sovPickRangeRule({
+      genitive: 'nin',
+      rangeSep: 'ile',
+      patientMarker: 'i',
+      eventMarker: 'de',
+    }),
   ],
 };
 
@@ -692,6 +939,8 @@ export const quechuaProfile: LanguageProfile = {
   morphology: 'agglutinative', // Actually polysynthetic
   direction: 'ltr',
 
+  // NOTE: roles absent from this order are safety-net-appended AFTER the verb
+  // (see the Turkish profile note) — extend via per-command `rules`, not here.
   canonicalOrder: ['patient', 'source', 'destination', 'event', 'action'],
 
   markers: [
@@ -705,6 +954,42 @@ export const quechuaProfile: LanguageProfile = {
     { form: 'wan', role: 'style', position: 'postposition', required: false },
     { form: 'hina', role: 'method', position: 'postposition', required: false }, // "as/like"
   ],
+
+  rules: [
+    {
+      name: 'wait-oblique-verb-final',
+      description: "Keep wait's from-phrase and or-run inside the clause, verb-final",
+      priority: 90,
+      match: {
+        commands: ['wait', 'suyay'],
+        // Only `wait for X or Y from Z` strands: duration is missing from
+        // canonicalOrder, so the or-run lands AFTER the verb and the next
+        // trigger glues it into its event (behavior-sortable R3). See the
+        // matching Turkish rule.
+        requiredRoles: ['action', 'duration', 'source'],
+        predicate: parsed => !parsed.roles.has('event'),
+      },
+      transform: {
+        // qillqa manta pointermove(clientY) utaq pointerup(clientY) suyay
+        roleOrder: ['patient', 'source', 'duration', 'action'],
+        insertMarkers: true,
+      },
+    },
+    // the ruway ta kachay pi sayay chayqa validateForm() ta qayay
+    sovHaltCallFusedRule({
+      callVerb: 'qayay',
+      patientMarker: 'ta',
+      eventMarker: 'pi',
+      connective: 'chayqa',
+    }),
+    // #note pa sanampa 0 kama 5 ta ñitiy pi akllay
+    sovPickRangeRule({
+      genitive: 'pa',
+      rangeSep: 'kama',
+      patientMarker: 'ta',
+      eventMarker: 'pi',
+    }),
+  ],
 };
 
 // =============================================================================
@@ -749,6 +1034,8 @@ export const bengaliProfile: LanguageProfile = {
 
   // Bengali: Object comes before verb, postpositions follow nouns
   // "on click increment #count" → "#count কে ক্লিক এ বৃদ্ধি"
+  // NOTE: roles absent from this order are safety-net-appended AFTER the verb
+  // (see the Turkish profile note) — extend via per-command `rules`, not here.
   canonicalOrder: ['patient', 'event', 'action'],
 
   markers: [
@@ -827,6 +1114,20 @@ export const bengaliProfile: LanguageProfile = {
         insertMarkers: true,
       },
     },
+    // the ঘটনা কে জমা এ থামুন তারপর validateForm() কে কল
+    sovHaltCallFusedRule({
+      callVerb: 'কল',
+      patientMarker: 'কে',
+      eventMarker: 'এ',
+      connective: 'তারপর',
+    }),
+    // #note র অক্ষর 0 থেকে 5 কে ক্লিক এ বাছুন
+    sovPickRangeRule({
+      genitive: 'র',
+      rangeSep: 'থেকে',
+      patientMarker: 'কে',
+      eventMarker: 'এ',
+    }),
   ],
 };
 
@@ -1040,6 +1341,20 @@ export const hindiProfile: LanguageProfile = {
         insertMarkers: true,
       },
     },
+    // the घटना को जमा पर रोकें फिर validateForm() को कॉल
+    sovHaltCallFusedRule({
+      callVerb: 'कॉल',
+      patientMarker: 'को',
+      eventMarker: 'पर',
+      connective: 'फिर',
+    }),
+    // #note का अक्षर 0 से 5 को क्लिक पर चुनें
+    sovPickRangeRule({
+      genitive: 'का',
+      rangeSep: 'से',
+      patientMarker: 'को',
+      eventMarker: 'पर',
+    }),
   ],
 };
 

package/src/grammar/transformer.ts

@@ -1901,6 +1901,18 @@ export class GrammarTransformer {
       return this.transformBlock(block);
     }
 
+    // 0a. Fragment carrying a stranded trailing block terminator (`wait 200ms
+    //     end`, `set x to y end` — what the `then`-splitter leaves from
+    //     `if … then <cmd> end`). `end` is not a marker, so left in place it is
+    //     swept into the open role's VALUE and rendered inside that phrase
+    //     (bn `200ms শেষ কে অপেক্ষা`). Strip it, transform the clause alone, and
+    //     re-append the translated terminator after the verb — the same tail
+    //     position transformBlockBody emits for event-headed blocks.
+    const strippedEnd = this.transformWithTrailingEnd(input);
+    if (strippedEnd !== null) {
+      return strippedEnd;
+    }
+
     // 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.
@@ -1951,6 +1963,36 @@ export class GrammarTransformer {
     return joinTokens(reordered.map(e => e.translated || e.value));
   }
 
+  /**
+   * `<command …> end` fragments: transform the command without its stranded
+   * terminator, then re-append the translated terminator as a standalone
+   * trailing token. Fragments that open a block of their own (`if … end`,
+   * `repeat … end`, `js … end`) bail — their terminator belongs to them and
+   * their dedicated paths handle it.
+   */
+  private transformWithTrailingEnd(input: string): string | null {
+    const src = this.sourceProfile.code;
+    const tokens = input.trim().split(/\s+/);
+    if (tokens.length < 2) {
+      return null;
+    }
+    const sourceEnd = translateWord('end', 'en', src).toLowerCase();
+    if (tokens[tokens.length - 1].toLowerCase() !== sourceEnd) {
+      return null;
+    }
+    const openers = new Set(
+      ['if', 'repeat', 'unless', 'while', 'when', 'live', 'js'].map(k =>
+        translateWord(k, 'en', src).toLowerCase()
+      )
+    );
+    if (tokens.slice(0, -1).some(t => openers.has(t.toLowerCase()))) {
+      return null;
+    }
+    const inner = this.transformSingle(tokens.slice(0, -1).join(' '));
+    const endT = translateWord(tokens[tokens.length - 1], src, this.targetProfile.code);
+    return `${inner} ${endT}`;
+  }
+
   /**
    * Detect and transform an inline JS block (`[on <event>] js <raw js> end`).
    *
@@ -2327,7 +2369,28 @@ export class GrammarTransformer {
     const clauseT = clause ? translateMultiWordValue(clause, src, dst) : '';
     const bodyT = this.transformConditionalBody(bodyTokens);
 
-    return [headT, clauseT, bodyT, tailT].filter(s => s.length > 0).join(' ');
+    // SOV condition/branch boundary (R1 deferred-tail Family G): the SOV body
+    // renders its first command operand-first (`最初 <button/> の中 .modal を
+    // フォーカス`), so nothing marks where the condition ends and the branch
+    // operand begins — the semantic fold's command-start detection needs a
+    // `{value}{particle}` run followed by a verb, which a POSITIONAL-headed
+    // operand (`first <button/> …`) never forms, and the condition scan
+    // swallows the operand's head (focus-trap: ja focus.patient fell to the
+    // `me` default, ko/qu to the `.modal` tail). Emit the target's
+    // then-connective at the seam — the boundary the fold already respects
+    // (isThenKeyword) — gated to exactly the blind shape: SOV target, a
+    // positional keyword right after the branch's command verb, and no `then`
+    // already ending the condition.
+    const POSITIONAL_BRANCH_HEADS = new Set(['first', 'last', 'next', 'previous', 'closest']);
+    const thenT =
+      this.targetProfile.wordOrder === 'SOV' &&
+      clauseT &&
+      POSITIONAL_BRANCH_HEADS.has(bodyTokens[1]?.toLowerCase()) &&
+      inner[bodyStart - 1]?.toLowerCase() !== 'then'
+        ? translateWord('then', src, dst)
+        : '';
+
+    return [headT, clauseT, thenT, bodyT, tailT].filter(s => s.length > 0).join(' ');
   }
 
   /**

package/src/new-languages.test.ts

@@ -47,7 +47,9 @@ describe('New Language Support', () => {
 
     it('should handle events properly', () => {
       const result = translator.translate('on mouseenter add .hover', { from: 'en', to: 'tr' });
-      expect(result).toContain('fare_gir');
+      // V3c burn-down 2026-07-14: fare_gir never round-tripped on the parse
+      // side (broken listener); mouseenter is English passthrough now.
+      expect(result).toContain('mouseenter');
       expect(result).toContain('ekle');
     });
 
@@ -198,8 +200,12 @@ describe('New Language Support', () => {
 
     it('should handle double-click events', () => {
       const result = translator.translate('on dblclick focus on me', { from: 'en', to: 'sw' });
-      expect(result).toContain('bonyeza_mara_mbili'); // dblclick → bonyeza_mara_mbili
-      expect(result).toContain('zingatia'); // focus → zingatia
+      // V3c burn-down 2026-07-14: bonyeza_mara_mbili never round-tripped on
+      // the parse side (broken listener); dblclick is English passthrough now.
+      expect(result).toContain('dblclick');
+      // V3 Batch 2: events.focus realigned zingatia → lenga (zingatia never
+      // tokenized as an event — matches commands.focus and the S5b table)
+      expect(result).toContain('lenga'); // focus → lenga
     });
 
     it('should translate navigation commands', () => {