@lokascript/i18n 2.5.1 → 2.6.0

package/src/grammar/transformer.ts

@@ -22,6 +22,7 @@ import { findInDictionary, translateFromEnglish } from '../types';
 import {
   ENGLISH_MODIFIER_ROLES,
   ENGLISH_COMMANDS,
+  COMMAND_PRIMARY_ROLES,
   CONDITIONAL_KEYWORDS,
   THEN_KEYWORDS,
 } from '../constants';
@@ -49,6 +50,104 @@ function getCommandKeywordsForLocale(locale: string): Set<string> {
   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: string): Set<string> {
+  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: string[], i: number, copulas: Set<string>): boolean {
+  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: string): { forWords: Set<string>; inWords: Set<string> } {
+  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: string[],
+  i: number,
+  inWords: Set<string>,
+  commandKeywords: Set<string>
+): boolean {
+  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: string): string {
+  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;
+}
+
 /**
  * Split a compound statement into parts at "then" boundaries, newlines,
  * AND command keyword boundaries.
@@ -140,11 +239,14 @@ function extractBlockStructure(input: string, sourceLocale: string): BlockStruct
   // `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;
     }
@@ -345,7 +447,13 @@ function reconstructWithLineStructure(
  * - "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',
@@ -360,6 +468,86 @@ const BOUNDARY_MODIFIERS = new Set([
   '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<string, Set<string>>();
+
+function getBoundaryModifiersForLocale(locale: string): Set<string> {
+  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: string[], commandKeywords: Set<string>): string | null {
+  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
@@ -373,8 +561,28 @@ const BOUNDARY_MODIFIERS = new Set([
  */
 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: string, sourceLocale: string): string[] {
   const commandKeywords = getCommandKeywordsForLocale(sourceLocale);
+  const boundaryModifiers = getBoundaryModifiersForLocale(sourceLocale);
+  const { forWords, inWords } = getForLoopWordsForLocale(sourceLocale);
   const tokens = input.split(/\s+/);
 
   if (tokens.length === 0) return [input];
@@ -429,7 +637,51 @@ function splitOnCommandBoundaries(input: string, sourceLocale: string): string[]
         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];
@@ -533,6 +785,31 @@ function deriveEventKeywordsFromProfiles(): Set<string> {
 /** 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
 // =============================================================================
@@ -572,6 +849,53 @@ function generateModifierMap(profile: LanguageProfile): Record<string, SemanticR
   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: LanguageProfile,
+  actionVerb: string | undefined
+): Record<string, SemanticRole> {
+  const map = generateModifierMap(profile);
+  const verb = actionVerb?.toLowerCase();
+  if (profile.wordOrder !== 'SVO' || !verb || !ON_TARGET_COMMANDS.has(verb)) {
+    return map;
+  }
+
+  const remapped: Record<string, SemanticRole> = {};
+  for (const [form, role] of Object.entries(map)) {
+    remapped[form] = role === 'event' ? 'destination' : role;
+  }
+  return remapped;
+}
+
 // =============================================================================
 // Statement Parser
 // =============================================================================
@@ -690,6 +1014,8 @@ function tokenize(input: string, profile: LanguageProfile): string[] {
   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];
@@ -703,8 +1029,41 @@ function tokenize(input: string, profile: LanguageProfile): string[] {
       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 = '';
@@ -766,11 +1125,30 @@ function parseEventHandler(tokens: string[], profile: LanguageProfile): ParsedSt
 
   // Next token is the event
   if (tokens[startIndex]) {
+    const eventTokens: string[] = [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 ...")
@@ -804,9 +1182,12 @@ function parseEventHandler(tokens: string[], profile: LanguageProfile): ParsedSt
   }
 
   // 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: SemanticRole = 'patient';
     let currentValue: string[] = [];
 
@@ -866,9 +1247,11 @@ function parseCommand(tokens: string[], profile: LanguageProfile): ParsedStateme
     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: SemanticRole = 'patient';
   let currentValue: string[] = [];
@@ -911,6 +1294,74 @@ function parseCommand(tokens: string[], profile: LanguageProfile): ParsedStateme
   };
 }
 
+/**
+ * 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: ReadonlySet<SemanticRole> = new Set<SemanticRole>([
+  'duration',
+  'quantity',
+]);
+
+function applyPrimaryRole(parsed: ParsedStatement, targetProfile: LanguageProfile): void {
+  // 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
  */
@@ -932,6 +1383,17 @@ function parseConditional(tokens: string[], _profile: LanguageProfile): ParsedSt
       role: 'condition',
       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 {
@@ -959,6 +1421,26 @@ function translateWord(word: string, sourceLocale: string, targetLocale: string)
     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];
 
@@ -984,7 +1466,7 @@ function translateWord(word: string, sourceLocale: string, targetLocale: string)
  */
 const POSSESSIVE_MARKERS: Record<
   string,
-  { type: 'prefix' | 'suffix' | 'preposition'; marker: string }
+  { type: 'prefix' | 'suffix' | 'preposition' | 'particle'; marker: string }
 > = {
   en: { type: 'suffix', marker: "'s" },
   es: { type: 'preposition', marker: 'de' },
@@ -995,9 +1477,21 @@ const POSSESSIVE_MARKERS: Record<
   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' },
 };
 
@@ -1040,6 +1534,10 @@ function translatePossessive(token: string, sourceLocale: string, 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
@@ -1126,6 +1624,21 @@ function translateMultiWordValue(
   sourceLocale: string,
   targetLocale: string
 ): string {
+  // 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: string[] = [];
+    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
@@ -1228,6 +1741,43 @@ function translateElements(
   }
 }
 
+// =============================================================================
+// 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: string): { masked: string; scopes: string[] } | null {
+  const scopes: string[] = [];
+  const masked = input.replace(CARET_SCOPE_RE, (_m, varTok: string, scope: string) => {
+    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: string, scopes: string[]): string {
+  return input.replace(
+    new RegExp(`${CARET_SCOPE_OPEN}(\\d+)${CARET_SCOPE_CLOSE}`, 'g'),
+    (_m, n: string) => scopes[Number(n)] ?? ''
+  );
+}
+
 // =============================================================================
 // Main Transformer
 // =============================================================================
@@ -1255,8 +1805,57 @@ export class GrammarTransformer {
    * For multi-line input, preserves line structure (indentation, blank lines).
    */
   transform(input: string): string {
+    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;
+  }
+
+  private transformInternal(input: string): string {
+    // 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');
 
@@ -1302,12 +1901,25 @@ export class GrammarTransformer {
       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);
 
@@ -1339,6 +1951,431 @@ export class GrammarTransformer {
     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).
+   */
+  private tryTransformJsBlock(input: string): string | null {
+    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`.
+   */
+  private tryTransformEventWithBlockBody(input: string): string | null {
+    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.
+   */
+  private tryTransformEventWithUnlessGuard(input: string): string | null {
+    // 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.
+   */
+  private tryTransformEventWithModifierBody(input: string): string | null {
+    // 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.
+   */
+  private transformSetWithScope(input: string): string | null {
+    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.
+   */
+  private transformBlockBody(blockTokens: string[]): string {
+    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.
+   */
+  private transformConditionalBody(bodyTokens: string[]): string {
+    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