@hyperfixi/core 2.8.0 → 2.9.0

package/dist/ast-utils/index.mjs

@@ -3754,6 +3754,9 @@ function isQuote(char) {
 function isDigit(char) {
   return /\d/.test(char);
 }
+function stripOptionalDiacritics(word) {
+  return word.replace(/[ً-ْٰ]/g, "");
+}
 function isAsciiLetter(char) {
   return /[a-zA-Z]/.test(char);
 }
@@ -4425,7 +4428,7 @@ var _BaseTokenizer = class _BaseTokenizer {
    * @returns Word without diacritics
    */
   removeDiacritics(word) {
-    return word.replace(/[\u064B-\u0652\u0670]/g, "");
+    return stripOptionalDiacritics(word);
   }
   /**
    * Try to match a keyword from profile at the current position.
@@ -4516,24 +4519,40 @@ var _BaseTokenizer = class _BaseTokenizer {
     });
   }
   /**
-   * Look up a keyword by native word (case-insensitive).
+   * Look up a keyword by native word (case-insensitive, diacritic-insensitive).
    * O(1) lookup using the keyword map.
    *
+   * The map is INDEXED both with and without diacritics (see
+   * `initializeKeywordsFromProfile`), so a stripped QUERY is the other half of
+   * that: it lets a surface form carrying harakat the profile does not happen to
+   * spell still find its entry. Only consulted after the exact lookup misses, so
+   * every previously-matching word resolves byte-identically.
+   *
+   * Half-implementing this — indexing stripped but querying exact — is what made
+   * diacritized `بَدِّل` (toggle) tokenize as `kind=particle normalized=with`:
+   * `isKeyword` returned false, so the guard in `ArabicProcliticExtractor` that
+   * exists to prevent exactly that handed the word on, and the single-char `ب`
+   * bi- proclitic claimed it. A wrong CONCEPT, not a failed parse.
+   *
    * @param native - Native word to look up
    * @returns KeywordEntry if found, undefined otherwise
    */
   lookupKeyword(native) {
-    return this.profileKeywordMap.get(native.toLowerCase());
+    const exact = this.profileKeywordMap.get(native.toLowerCase());
+    if (exact) return exact;
+    const stripped = this.removeDiacritics(native);
+    if (stripped === native) return void 0;
+    return this.profileKeywordMap.get(stripped.toLowerCase());
   }
   /**
-   * Check if a word is a known keyword (case-insensitive).
-   * O(1) lookup using the keyword map.
+   * Check if a word is a known keyword (case-insensitive, diacritic-insensitive).
+   * O(1) lookup using the keyword map. See {@link lookupKeyword}.
    *
    * @param native - Native word to check
    * @returns true if the word is a keyword
    */
   isKeyword(native) {
-    return this.profileKeywordMap.has(native.toLowerCase());
+    return this.lookupKeyword(native) !== void 0;
   }
   /**
    * Set the morphological normalizer for this tokenizer.
@@ -5181,9 +5200,12 @@ var init_arabic = __esm({
         behavior: { primary: "\u0633\u0644\u0648\u0643", normalized: "behavior" },
         install: { primary: "\u062A\u062B\u0628\u064A\u062A", alternatives: ["\u062B\u0628\u0651\u062A"], normalized: "install" },
         // `قِس` is the imperative with the kasra diacritic; the i18n dict (and real
-        // Arabic prose) emits it undiacritized as `قس`, so list both — otherwise the
-        // generated `قس width`/`قس x` (behavior-draggable/resizable) parse to null and
-        // the whole `measure` command drops from the event-handler body (lossy).
+        // Arabic prose) emits it undiacritized as `قس`. BOTH stay listed, and not
+        // for the tokenizer's sake — keyword lookup is diacritic-insensitive now, so
+        // either spelling resolves. It is the vocab gate's V1 check, which compares
+        // the profile against the i18n DICTIONARY as strings: the dictionary says
+        // `قس`, so dropping it here fails V1 (verified). Diacritic-insensitivity
+        // would have to reach that comparison too before this pair can collapse.
         measure: { primary: "\u0642\u064A\u0627\u0633", alternatives: ["\u0642\u0650\u0633", "\u0642\u0633"], normalized: "measure" },
         beep: { primary: "\u0635\u0641\u0651\u0631", normalized: "beep" },
         break: { primary: "\u062A\u0648\u0642\u0641", normalized: "break" },
@@ -5867,6 +5889,15 @@ var init_spanish = __esm({
         patient: { primary: "", position: "before" },
         style: { primary: "con", position: "before" }
       },
+      // Imperative command forms are accepted on INPUT only — `primary` stays the
+      // dictionary form, so rendering is unchanged (see LanguageProfile.defaultVerbForm:
+      // infinitive is the industry standard for UI localization). Hyperscript is a
+      // command language, though, and a native speaker giving a command writes the
+      // imperative, so the parser should read it.
+      //
+      // Only the IRREGULARS are listed. The regular ones reach their keyword through
+      // the morphological normalizer's stem (see spanish-keyword.ts and siblings),
+      // which also covers conjugations nobody enumerated here.
       keywords: {
         // Class/Attribute operations
         toggle: { primary: "alternar", alternatives: ["conmutar", "toggle"], normalized: "toggle" },
@@ -5886,19 +5917,23 @@ var init_spanish = __esm({
         swap: { primary: "intercambiar", alternatives: ["permutar"], normalized: "swap" },
         morph: { primary: "transformar", alternatives: ["convertir"], normalized: "morph" },
         // Variable operations
-        set: { primary: "establecer", alternatives: ["fijar", "definir"], normalized: "set" },
-        get: { primary: "obtener", alternatives: ["conseguir"], normalized: "get" },
+        set: {
+          primary: "establecer",
+          alternatives: ["fijar", "definir", "establece"],
+          normalized: "set"
+        },
+        get: { primary: "obtener", alternatives: ["conseguir", "obt\xE9n"], normalized: "get" },
         increment: { primary: "incrementar", alternatives: ["aumentar"], normalized: "increment" },
         decrement: { primary: "decrementar", alternatives: ["disminuir"], normalized: "decrement" },
         log: { primary: "registrar", alternatives: ["imprimir"], normalized: "log" },
         // Visibility
-        show: { primary: "mostrar", alternatives: ["ense\xF1ar"], normalized: "show" },
+        show: { primary: "mostrar", alternatives: ["ense\xF1ar", "muestra"], normalized: "show" },
         hide: { primary: "ocultar", alternatives: ["esconder"], normalized: "hide" },
         transition: { primary: "transici\xF3n", alternatives: ["animar"], normalized: "transition" },
         // Events
         on: { primary: "en", alternatives: ["al"], normalized: "on" },
         trigger: { primary: "disparar", alternatives: ["activar"], normalized: "trigger" },
-        send: { primary: "enviar", normalized: "send" },
+        send: { primary: "enviar", alternatives: ["env\xEDa"], normalized: "send" },
         // DOM focus
         focus: { primary: "enfocar", alternatives: ["enfoque"], normalized: "focus" },
         blur: { primary: "desenfocar", alternatives: ["desenfoque"], normalized: "blur" },
@@ -5935,7 +5970,7 @@ var init_spanish = __esm({
         mousedown: { primary: "rat\xF3nabajo", normalized: "mousedown" },
         mouseup: { primary: "rat\xF3narriba", normalized: "mouseup" },
         // Navigation
-        go: { primary: "ir", alternatives: ["navegar"], normalized: "go" },
+        go: { primary: "ir", alternatives: ["navegar", "ve"], normalized: "go" },
         push: { primary: "empujar", alternatives: ["push"], normalized: "push" },
         replace: { primary: "reemplazar", alternatives: ["sustituir"], normalized: "replace" },
         process: { primary: "procesar", normalized: "process" },
@@ -6124,11 +6159,24 @@ var init_french = __esm({
         patient: { primary: "", position: "before" },
         style: { primary: "avec", position: "before" }
       },
+      // Imperative command forms are accepted on INPUT only — `primary` stays the
+      // dictionary form, so rendering is unchanged (see LanguageProfile.defaultVerbForm:
+      // infinitive is the industry standard for UI localization). Hyperscript is a
+      // command language, though, and a native speaker giving a command writes the
+      // imperative, so the parser should read it.
+      //
+      // Only the IRREGULARS are listed. The regular ones reach their keyword through
+      // the morphological normalizer's stem (see spanish-keyword.ts and siblings),
+      // which also covers conjugations nobody enumerated here.
       keywords: {
         toggle: { primary: "basculer", alternatives: ["alterner"], normalized: "toggle" },
         add: { primary: "ajouter", normalized: "add" },
-        remove: { primary: "supprimer", alternatives: ["enlever", "retirer"], normalized: "remove" },
-        put: { primary: "mettre", alternatives: ["placer"], normalized: "put" },
+        remove: {
+          primary: "supprimer",
+          alternatives: ["enlever", "retirer", "retire"],
+          normalized: "remove"
+        },
+        put: { primary: "mettre", alternatives: ["placer", "mets"], normalized: "put" },
         append: { primary: "annexer", normalized: "append" },
         prepend: { primary: "pr\xE9fixer", normalized: "prepend" },
         take: { primary: "prendre", normalized: "take" },
@@ -6137,16 +6185,16 @@ var init_french = __esm({
         swap: { primary: "\xE9changer", alternatives: ["permuter"], normalized: "swap" },
         morph: { primary: "transformer", alternatives: ["m\xE9tamorphoser"], normalized: "morph" },
         set: { primary: "d\xE9finir", alternatives: ["\xE9tablir"], normalized: "set" },
-        get: { primary: "obtenir", normalized: "get" },
+        get: { primary: "obtenir", alternatives: ["obtiens"], normalized: "get" },
         increment: { primary: "incr\xE9menter", alternatives: ["augmenter"], normalized: "increment" },
         decrement: { primary: "d\xE9cr\xE9menter", alternatives: ["diminuer"], normalized: "decrement" },
         log: { primary: "enregistrer", alternatives: ["journaliser"], normalized: "log" },
-        show: { primary: "montrer", alternatives: ["afficher"], normalized: "show" },
+        show: { primary: "montrer", alternatives: ["afficher", "montre"], normalized: "show" },
         hide: { primary: "cacher", alternatives: ["masquer"], normalized: "hide" },
         transition: { primary: "transition", alternatives: ["animer"], normalized: "transition" },
         on: { primary: "sur", alternatives: ["lors"], normalized: "on" },
         trigger: { primary: "d\xE9clencher", normalized: "trigger" },
-        send: { primary: "envoyer", normalized: "send" },
+        send: { primary: "envoyer", alternatives: ["envoie"], normalized: "send" },
         focus: { primary: "focaliser", alternatives: ["concentrer"], normalized: "focus" },
         blur: { primary: "d\xE9focaliser", normalized: "blur" },
         // Phase 1 (v0.9.90): DOM / form state / debug
@@ -6160,13 +6208,13 @@ var init_french = __esm({
         clear: { primary: "effacer", normalized: "clear" },
         reset: { primary: "r\xE9initialiser", alternatives: ["reinitialiser"], normalized: "reset" },
         breakpoint: { primary: "point-arr\xEAt", alternatives: ["point-arret"], normalized: "breakpoint" },
-        go: { primary: "aller", alternatives: ["naviguer"], normalized: "go" },
+        go: { primary: "aller", alternatives: ["naviguer", "va"], normalized: "go" },
         scroll: { primary: "d\xE9filer", alternatives: ["faire-d\xE9filer"], normalized: "scroll" },
         push: { primary: "pousser", normalized: "push" },
         replace: { primary: "remplacer", normalized: "replace" },
         process: { primary: "traiter", normalized: "process" },
         wait: { primary: "attendre", normalized: "wait" },
-        fetch: { primary: "chercher", alternatives: ["r\xE9cup\xE9rer"], normalized: "fetch" },
+        fetch: { primary: "chercher", alternatives: ["r\xE9cup\xE9rer", "r\xE9cup\xE8re"], normalized: "fetch" },
         settle: { primary: "stabiliser", normalized: "settle" },
         if: { primary: "si", normalized: "if" },
         unless: { primary: "saufsi", normalized: "unless" },
@@ -7537,16 +7585,25 @@ var init_korean = __esm({
         event: { primary: "\uC744", alternatives: ["\uB97C"], position: "after" }
         // Event as object marker
       },
+      // Imperative command forms are accepted on INPUT only — `primary` stays the
+      // dictionary form, so rendering is unchanged (see LanguageProfile.defaultVerbForm:
+      // infinitive is the industry standard for UI localization). Hyperscript is a
+      // command language, though, and a native speaker giving a command writes the
+      // imperative, so the parser should read it.
+      //
+      // Only the IRREGULARS are listed. The regular ones reach their keyword through
+      // the morphological normalizer's stem (see spanish-keyword.ts and siblings),
+      // which also covers conjugations nobody enumerated here.
       keywords: {
         // Class/Attribute operations
         toggle: { primary: "\uD1A0\uAE00", normalized: "toggle" },
         add: { primary: "\uCD94\uAC00", normalized: "add" },
         remove: { primary: "\uC81C\uAC70", alternatives: ["\uC0AD\uC81C"], normalized: "remove" },
         // Content operations
-        put: { primary: "\uB123\uB2E4", alternatives: ["\uB123\uAE30", "\uB193\uAE30"], normalized: "put" },
+        put: { primary: "\uB123\uB2E4", alternatives: ["\uB123\uAE30", "\uB193\uAE30", "\uB123\uC73C\uC138\uC694"], normalized: "put" },
         append: { primary: "\uB367\uBD99\uC774\uB2E4", alternatives: ["\uB05D\uC5D0\uCD94\uAC00"], normalized: "append" },
         prepend: { primary: "\uC55E\uC5D0\uCD94\uAC00", alternatives: ["\uC120\uB450\uCD94\uAC00"], normalized: "prepend" },
-        take: { primary: "\uAC00\uC838\uC624\uB2E4", normalized: "take" },
+        take: { primary: "\uAC00\uC838\uC624\uB2E4", alternatives: ["\uAC00\uC838\uC624\uC138\uC694"], normalized: "take" },
         make: { primary: "\uB9CC\uB4E4\uB2E4", normalized: "make" },
         clone: { primary: "\uBCF5\uC81C", normalized: "clone" },
         // 복제=duplicate/clone, 복사=copy
@@ -7554,13 +7611,13 @@ var init_korean = __esm({
         morph: { primary: "\uBCC0\uD615", alternatives: ["\uBCC0\uD658"], normalized: "morph" },
         // Variable operations
         set: { primary: "\uC124\uC815", normalized: "set" },
-        get: { primary: "\uC5BB\uB2E4", normalized: "get" },
+        get: { primary: "\uC5BB\uB2E4", alternatives: ["\uC5BB\uC73C\uC138\uC694"], normalized: "get" },
         increment: { primary: "\uC99D\uAC00", normalized: "increment" },
         decrement: { primary: "\uAC10\uC18C", normalized: "decrement" },
         log: { primary: "\uB85C\uADF8", normalized: "log" },
         // Visibility
-        show: { primary: "\uBCF4\uC774\uB2E4", alternatives: ["\uD45C\uC2DC", "\uBCF4\uC774\uAE30"], normalized: "show" },
-        hide: { primary: "\uC228\uAE30\uB2E4", alternatives: ["\uC228\uAE30\uAE30"], normalized: "hide" },
+        show: { primary: "\uBCF4\uC774\uB2E4", alternatives: ["\uD45C\uC2DC", "\uBCF4\uC774\uAE30", "\uBCF4\uC774\uC138\uC694"], normalized: "show" },
+        hide: { primary: "\uC228\uAE30\uB2E4", alternatives: ["\uC228\uAE30\uAE30", "\uC228\uAE30\uC138\uC694"], normalized: "hide" },
         // primary is the loanword 트랜지션; 전환 ("switch/transition") is the form the
         // i18n transformer emits — registered as an alternative (passthrough-alignment).
         // toggle uses 토글, so 전환 carries no collision.
@@ -7568,7 +7625,7 @@ var init_korean = __esm({
         // Events
         on: { primary: "\uC5D0", alternatives: ["\uC2DC", "\uD560 \uB54C"], normalized: "on" },
         trigger: { primary: "\uD2B8\uB9AC\uAC70", normalized: "trigger" },
-        send: { primary: "\uBCF4\uB0B4\uB2E4", normalized: "send" },
+        send: { primary: "\uBCF4\uB0B4\uB2E4", alternatives: ["\uBCF4\uB0B4\uC138\uC694"], normalized: "send" },
         // DOM focus
         focus: { primary: "\uD3EC\uCEE4\uC2A4", normalized: "focus" },
         blur: { primary: "\uBE14\uB7EC", normalized: "blur" },
@@ -8350,25 +8407,38 @@ var init_portuguese = __esm({
         patient: { primary: "", position: "before" },
         style: { primary: "com", position: "before" }
       },
+      // Imperative command forms are accepted on INPUT only — `primary` stays the
+      // dictionary form, so rendering is unchanged (see LanguageProfile.defaultVerbForm:
+      // infinitive is the industry standard for UI localization). Hyperscript is a
+      // command language, though, and a native speaker giving a command writes the
+      // imperative, so the parser should read it.
+      //
+      // Only the IRREGULARS are listed. The regular ones reach their keyword through
+      // the morphological normalizer's stem (see spanish-keyword.ts and siblings),
+      // which also covers conjugations nobody enumerated here.
       keywords: {
         toggle: { primary: "alternar", alternatives: [], normalized: "toggle" },
         add: { primary: "adicionar", alternatives: ["acrescentar"], normalized: "add" },
-        remove: { primary: "remover", alternatives: ["eliminar", "apagar"], normalized: "remove" },
-        put: { primary: "colocar", alternatives: ["p\xF4r", "por"], normalized: "put" },
+        remove: {
+          primary: "remover",
+          alternatives: ["eliminar", "apagar", "remova"],
+          normalized: "remove"
+        },
+        put: { primary: "colocar", alternatives: ["p\xF4r", "por", "coloque"], normalized: "put" },
         append: { primary: "anexar", normalized: "append" },
         prepend: { primary: "preceder", normalized: "prepend" },
-        take: { primary: "pegar", normalized: "take" },
+        take: { primary: "pegar", alternatives: ["pegue"], normalized: "take" },
         make: { primary: "fazer", alternatives: ["criar"], normalized: "make" },
         clone: { primary: "clonar", alternatives: [], normalized: "clone" },
         swap: { primary: "trocar", alternatives: ["substituir"], normalized: "swap" },
         morph: { primary: "transformar", alternatives: ["converter"], normalized: "morph" },
-        set: { primary: "definir", alternatives: ["configurar"], normalized: "set" },
-        get: { primary: "obter", normalized: "get" },
+        set: { primary: "definir", alternatives: ["configurar", "defina"], normalized: "set" },
+        get: { primary: "obter", alternatives: ["obtenha"], normalized: "get" },
         increment: { primary: "incrementar", alternatives: ["aumentar"], normalized: "increment" },
         decrement: { primary: "decrementar", alternatives: ["diminuir"], normalized: "decrement" },
         log: { primary: "registrar", alternatives: ["imprimir"], normalized: "log" },
         show: { primary: "mostrar", alternatives: ["exibir"], normalized: "show" },
-        hide: { primary: "ocultar", alternatives: ["esconder"], normalized: "hide" },
+        hide: { primary: "ocultar", alternatives: ["esconder", "esconda"], normalized: "hide" },
         transition: { primary: "transi\xE7\xE3o", alternatives: ["animar"], normalized: "transition" },
         on: { primary: "em", alternatives: ["ao"], normalized: "on" },
         trigger: { primary: "disparar", alternatives: ["ativar"], normalized: "trigger" },
@@ -8387,13 +8457,13 @@ var init_portuguese = __esm({
           alternatives: ["ponto-interrupcao"],
           normalized: "breakpoint"
         },
-        go: { primary: "ir", alternatives: ["navegar"], normalized: "go" },
+        go: { primary: "ir", alternatives: ["navegar", "v\xE1"], normalized: "go" },
         scroll: { primary: "rolar", alternatives: ["scroll"], normalized: "scroll" },
         push: { primary: "empurrar", alternatives: ["push"], normalized: "push" },
         replace: { primary: "repor", alternatives: ["recolocar"], normalized: "replace" },
         process: { primary: "processar", normalized: "process" },
         wait: { primary: "esperar", alternatives: ["aguardar"], normalized: "wait" },
-        fetch: { primary: "buscar", normalized: "fetch" },
+        fetch: { primary: "buscar", alternatives: ["busque"], normalized: "fetch" },
         settle: { primary: "estabilizar", normalized: "settle" },
         if: { primary: "se", normalized: "if" },
         // salvo — single token ('salvo se' = unless). a_menos kept as an
@@ -11464,8 +11534,53 @@ var init_command_schemas = __esm({
           default: { type: "reference", value: "me" },
           svoPosition: 2,
           sovPosition: 1,
-          markerOverride: { en: "to" }
-          // "add .class to #element"
+          // `add` is directional, but every profile's `destination` marker is
+          // LOCATIVE (en on, es en, ar على, zh 在, fr sur, de auf, pt em) because
+          // it also serves `toggle`/`show`. Without a per-language override the
+          // rendered text said "add .class ON #element" in every language but
+          // English — the gap lokascript-learn corrects with 6 of its 16 override
+          // entries. ja に / ko 에 / tr e are already directional, so they keep
+          // the profile default.
+          //
+          // Tier B (2.9): he/id/it/sw were the remaining locatives that this
+          // language actually distinguishes.
+          //   he — `על` is "ON"; Hebrew adds with the allative `אל` (`ל` is a bound
+          //        prefix, so it cannot stand as a separate marker token).
+          //   id — `pada` is "at/on"; `ke` is the directional, and it is what the
+          //        i18n corpus already renders for every id destination.
+          //   it — `in` is locative; Italian adds with `a` (`aggiungere a`).
+          //   sw — `kwenye` is not merely locative, it is sw's EVENT keyword
+          //        (`on: 'kwenye'` in the dictionary), so reusing it as a
+          //        destination marker collides. `kwa` is the corpus rendering.
+          // hi `में` / ru+uk `в` / th `ใน` / vi `vào` are already the right
+          // container-directional for "add to", and keep the profile default.
+          markerOverride: {
+            en: "to",
+            es: "a",
+            ar: "\u0625\u0644\u0649",
+            zh: "\u5230",
+            fr: "\xE0",
+            de: "zu",
+            pt: "a",
+            he: "\u05D0\u05DC",
+            id: "ke",
+            it: "a",
+            sw: "kwa"
+          },
+          // Each language's previous primary marker (and its alternates) still
+          // parses, so source written against ≤2.8 keeps working.
+          markerLegacy: {
+            es: ["en", "sobre", "hacia"],
+            ar: ["\u0639\u0644\u0649", "\u0641\u064A", "\u0628"],
+            zh: ["\u5728", "\u4E8E"],
+            fr: ["sur", "dans"],
+            de: ["auf", "in"],
+            pt: ["em", "para"],
+            he: ["\u05E2\u05DC", "\u05D1", "\u05DC"],
+            id: ["pada", "di"],
+            it: ["in", "su"],
+            sw: ["kwenye"]
+          }
         }
       ],
       // Runtime error documentation
@@ -11555,12 +11670,39 @@ var init_command_schemas = __esm({
           svoPosition: 2,
           sovPosition: 2,
           // SOV: destination comes second (に/에/a marker)
-          markerOverride: { en: "into" },
-          // "put 'hello' into #output"
+          // "put 'hello' into #output" — directional, so the same locative-default
+          // correction as `add`. es `en` and pt `em` are already right for "into",
+          // as are ja に / ko 에 / tr e; only ar/zh/fr/de need an override.
+          //
+          // Tier B (2.9): `put` is ILLATIVE, so it diverges from `add` where the
+          // two senses differ. he takes `ב` ("in/into" — `שים ב`), NOT the allative
+          // `אל` that `add`/`go` take. it keeps its locative `in` (`mettere in`) —
+          // it is `add`/`go` that needed `a`. id/sw change for the same reason as
+          // `add` (directional / event-keyword collision). hi `में`, ru+uk `в`,
+          // th `ใน` and vi `vào` are all already the illative.
+          markerOverride: {
+            en: "into",
+            ar: "\u0641\u064A",
+            zh: "\u5230",
+            fr: "dans",
+            de: "in",
+            he: "\u05D1",
+            id: "ke",
+            sw: "kwa"
+          },
           // `before` / `after` are alternate position markers; the matched marker
           // is recorded as a literal in the `method` role (a derived role with no
           // surface form of its own — populated by schema-driven role inference).
           markerVariants: { en: ["before", "after"] },
+          markerLegacy: {
+            ar: ["\u0639\u0644\u0649", "\u0625\u0644\u0649", "\u0628"],
+            zh: ["\u5728", "\u4E8E"],
+            fr: ["sur", "\xE0"],
+            de: ["auf", "zu"],
+            he: ["\u05E2\u05DC", "\u05D0\u05DC", "\u05DC"],
+            id: ["pada", "di"],
+            sw: ["kwenye"]
+          },
           methodCarrier: "method"
         }
       ],
@@ -11695,8 +11837,11 @@ var init_command_schemas = __esm({
           // ending in a vowel (`doğru ya` = "true" in set-attribute). markerOverride
           // is a single string, so the generated tr set patterns carried only `e`
           // and set-attribute fell to the role-scrambling generic SOV extraction.
-          // markerVariants supplies the allomorphs the SOV two-role generators merge
-          // in as marker alternatives. See STRUCTURAL_ARCS_ROADMAP.md (tr set-attribute).
+          // markerVariants supplies the allomorphs, merged in as marker alternatives.
+          // Until 2026-07-25 only the SOV two-role generators merged them, so this
+          // worked ONLY inside an event handler: `@disabled i doğru ya ayarla` did
+          // not parse as a bare command while `tıklama da @disabled i doğru ya
+          // ayarla` did. See STRUCTURAL_ARCS_ROADMAP.md (tr set-attribute).
           markerVariants: {
             tr: ["e", "a", "ye", "ya"]
           }
@@ -12628,17 +12773,100 @@ var init_command_schemas = __esm({
           expectedTypes: ["literal", "expression"],
           svoPosition: 1,
           sovPosition: 1,
-          markerOverride: { en: "to" },
-          // "go to /page" (parsing)
-          renderOverride: { en: "" },
-          // "go /page" (rendering — no preposition)
+          // "go to /page" (parsing). Directional, so the same locative-default
+          // correction as `add`/`put`.
+          //
+          // Tier B (2.9): `go` is pure ALLATIVE — motion toward a target — so it
+          // needs the directional in more languages than `add`/`put` do, including
+          // ones where a container-locative was fine for those two.
+          //   he — `אל` ("toward"), as `add`; `לך על url` read "go ON url".
+          //   hi — `पर`: Hindi navigates to a page with `पर जाएं`; `में` is
+          //        "go INTO", which is entering a place, not opening a URL.
+          //   id — `ke`, as `add`.
+          //   it — `a`: `andare a` for a specific target (`andare in` is for
+          //        regions — `andare in Italia`).
+          //   ru/uk — `на`: `перейти на сторінку` is the navigation idiom; `в`
+          //        ("into") is right for `add`/`put` but not for opening a page.
+          //   sw — `kwa`, as `add`.
+          // th is NOT here — it renders bare, with zh and vi; see below.
+          markerOverride: {
+            en: "to",
+            es: "a",
+            ar: "\u0625\u0644\u0649",
+            fr: "\xE0",
+            de: "zu",
+            pt: "para",
+            he: "\u05D0\u05DC",
+            hi: "\u092A\u0930",
+            id: "ke",
+            it: "a",
+            ru: "\u043D\u0430",
+            sw: "kwa",
+            uk: "\u043D\u0430"
+          },
+          // "go /page" (rendering — no preposition).
+          //
+          // zh, vi and th render BARE.
+          //
+          // zh and vi because their `go` keyword already encodes the direction, so
+          // any destination marker is a second one: zh `前往` is "proceed-to"
+          // (`前往 到 url` = "proceed-to to url") and vi `đi đến` is literally
+          // "go to" (`đi đến vào url` = "go-to into url"). Both are corrected in
+          // the i18n corpus in the same change
+          // (`patterns-reference/scripts/fix-translations.sql`).
+          //
+          // th because Thai motion verbs take a BARE destination — `ไปบ้าน`
+          // ("go home"), `ไปโรงเรียน` ("go school") — so `ไป url` is the idiomatic
+          // form. The profile default rendered `ไป ใน url` ("go IN url"), which is
+          // what needed fixing; the obvious replacement `ยัง` (giving the formal
+          // `ไปยัง`) is rejected because `ยัง` is also the very common adverb
+          // "still/yet", and the V4 vocab gate correctly refuses to classify it as
+          // a particle — promoting it would mis-tokenize ordinary Thai.
+          //
+          // Parsing is unaffected for all three: none has a `markerOverride`, so
+          // each stays on the profile-default branch and keeps accepting its old
+          // markers (th `ใน` / `ไปยัง`) from the profile itself.
+          renderOverride: { en: "", zh: "", vi: "", th: "" },
           // `go back` renders the destination bare in en (history nav has no `to`),
           // and he/zh render it with their PATIENT marker (לך את back / 前往 把 back)
           // while go-url keeps the destination marker (לך על url / 前往 到 url) —
           // the corpus is ground truth, so en's `to` is optional and he/zh accept
           // the patient particle as a destination-marker alternative, scoped to go.
-          markerOptional: { en: true },
-          markerVariants: { he: ["\u05D0\u05EA"], zh: ["\u628A"] }
+          // The render side drops the preposition for these four, so the parse
+          // side cannot require it: `go /page`, `前往 url`, `đi đến url`, `ไป url`
+          // must parse alongside the marked forms the profile still accepts.
+          markerOptional: { en: true, zh: true, vi: true, th: true },
+          // zh renders `前往 把 back` with its PATIENT particle before go's
+          // destination — a synonym here, not a distinct shape, so it is accepted as
+          // a marker alternative scoped to go. he's `את` is the same thing and sits
+          // in `markerLegacy` below: it moved there in #763 because the two fields
+          // were then read by DIFFERENT branches, so leaving it here silently
+          // stopped `לך את back` parsing the moment he gained a `markerOverride`.
+          // Both fields now merge on both branches (`schemaMarkerAlternatives`), so
+          // that trap is gone and the split is historical.
+          markerVariants: { zh: ["\u628A"] },
+          markerLegacy: {
+            es: ["en", "sobre", "hacia"],
+            ar: ["\u0639\u0644\u0649", "\u0641\u064A", "\u0628"],
+            fr: ["sur", "dans"],
+            de: ["auf", "in"],
+            pt: ["em", "a"],
+            // `את` is he's PATIENT particle, which the transformer renders before
+            // go's destination in `go back` (`לך את back`) — a parse-only synonym
+            // here, never rendered, which is exactly what markerLegacy is for.
+            he: ["\u05E2\u05DC", "\u05D1", "\u05DC", "\u05D0\u05EA"],
+            hi: ["\u092E\u0947\u0902"],
+            id: ["pada", "di"],
+            it: ["in", "su"],
+            ru: ["\u0432", "\u043A"],
+            sw: ["kwenye"],
+            uk: ["\u0432", "\u0434\u043E"]
+            // zh, vi and th are NOT listed: none has a markerOverride, so all three
+            // stay on the profile-default branch and keep accepting their old
+            // markers from the profile itself. Only their RENDERING changed.
+            // Listing them here would be dead config — markerLegacy is read ONLY by
+            // the override branch.
+          }
         }
       ],
       // `go to url "/page"` — without this variant the destination captures the
@@ -13640,7 +13868,7 @@ var init_command_schemas = __esm({
         roles: []
       }
     };
-    if (typeof process !== "undefined" && process.env.NODE_ENV !== "production") {
+    if (typeof process !== "undefined" && process.env.LOKASCRIPT_SCHEMA_VALIDATION === "1") {
       Promise.resolve().then(() => (init_schema_validator(), schema_validator_exports)).then(({ validateAllSchemas: validateAllSchemas2, formatValidationResults: formatValidationResults2 }) => {
         const validations = validateAllSchemas2(commandSchemas);
         if (validations.size > 0) {
@@ -20197,12 +20425,16 @@ var init_spanish_keyword = __esm({
         const keywordEntry = this.context.lookupKeyword(word);
         const normalized2 = keywordEntry && keywordEntry.normalized !== keywordEntry.native ? keywordEntry.normalized : void 0;
         let morphNormalized;
+        let morphStem;
+        let morphConfidence;
         if (!keywordEntry && this.context.normalizer) {
           const morphResult = this.context.normalizer.normalize(word);
           if (morphResult.stem !== word && morphResult.confidence >= 0.7) {
             const stemEntry = this.context.lookupKeyword(morphResult.stem);
             if (stemEntry) {
               morphNormalized = stemEntry.normalized;
+              morphStem = morphResult.stem;
+              morphConfidence = morphResult.confidence;
             }
           }
         }
@@ -20211,6 +20443,8 @@ var init_spanish_keyword = __esm({
           length: pos2 - position,
           metadata: {
             normalized: normalized2 || morphNormalized,
+            stem: morphStem,
+            stemConfidence: morphConfidence,
             isPreposition
           }
         };
@@ -21330,12 +21564,16 @@ var init_portuguese_keyword = __esm({
         const keywordEntry = this.context.lookupKeyword(lower);
         const normalized2 = keywordEntry && keywordEntry.normalized !== keywordEntry.native ? keywordEntry.normalized : void 0;
         let morphNormalized;
+        let morphStem;
+        let morphConfidence;
         if (!keywordEntry && this.context.normalizer) {
           const morphResult = this.context.normalizer.normalize(word);
           if (morphResult.stem !== word && morphResult.confidence >= 0.7) {
             const stemEntry = this.context.lookupKeyword(morphResult.stem);
             if (stemEntry) {
               morphNormalized = stemEntry.normalized;
+              morphStem = morphResult.stem;
+              morphConfidence = morphResult.confidence;
             }
           }
         }
@@ -21344,6 +21582,8 @@ var init_portuguese_keyword = __esm({
           length: pos2 - position,
           metadata: {
             normalized: normalized2 || morphNormalized,
+            stem: morphStem,
+            stemConfidence: morphConfidence,
             isPreposition
           }
         };
@@ -21823,12 +22063,16 @@ var init_french_keyword = __esm({
         const keywordEntry = this.context.lookupKeyword(lower);
         const normalized2 = keywordEntry && keywordEntry.normalized !== keywordEntry.native ? keywordEntry.normalized : void 0;
         let morphNormalized;
+        let morphStem;
+        let morphConfidence;
         if (!keywordEntry && this.context.normalizer) {
           const morphResult = this.context.normalizer.normalize(word);
           if (morphResult.stem !== word && morphResult.confidence >= 0.7) {
             const stemEntry = this.context.lookupKeyword(morphResult.stem);
             if (stemEntry) {
               morphNormalized = stemEntry.normalized;
+              morphStem = morphResult.stem;
+              morphConfidence = morphResult.confidence;
             }
           }
         }
@@ -21837,6 +22081,8 @@ var init_french_keyword = __esm({
           length: pos2 - position,
           metadata: {
             normalized: normalized2 || morphNormalized,
+            stem: morphStem,
+            stemConfidence: morphConfidence,
             isPreposition
           }
         };
@@ -28419,8 +28665,10 @@ function resolveMarkerForRole(roleSpec, profile) {
   const overrideMarker = roleSpec.markerOverride?.[profile.code];
   const defaultMarker = profile.roleMarkers[roleSpec.role];
   if (overrideMarker !== void 0) {
+    const alternatives = legacyMarkerAlternatives(roleSpec, profile.code, overrideMarker);
     return {
       primary: overrideMarker,
+      ...alternatives && { alternatives },
       position: defaultMarker?.position ?? "before",
       isOverride: true
     };
@@ -28438,6 +28686,18 @@ function resolveMarkerForRole(roleSpec, profile) {
   }
   return null;
 }
+function legacyMarkerAlternatives(roleSpec, languageCode, overrideMarker) {
+  const legacy = roleSpec.markerLegacy?.[languageCode];
+  if (!legacy?.length) return void 0;
+  const alternatives = [...new Set(legacy)].filter((a) => a && a !== overrideMarker);
+  return alternatives.length ? alternatives : void 0;
+}
+function schemaMarkerAlternatives(roleSpec, languageCode, marker) {
+  const legacy = roleSpec.markerLegacy?.[languageCode] ?? [];
+  const variants = roleSpec.methodCarrier ? [] : roleSpec.markerVariants?.[languageCode] ?? [];
+  const alternatives = [.../* @__PURE__ */ new Set([...legacy, ...variants])].filter((a) => a && a !== marker);
+  return alternatives.length ? alternatives : void 0;
+}
 var init_marker_resolution = __esm({
   "src/parser/utils/marker-resolution.ts"() {
   }
@@ -28449,20 +28709,17 @@ function resolveRoleMarker(roleSpec, profile) {
   let alternatives;
   if (roleSpec.markerOverride && roleSpec.markerOverride[profile.code] !== void 0) {
     marker = roleSpec.markerOverride[profile.code];
+    alternatives = marker ? schemaMarkerAlternatives(roleSpec, profile.code, marker) : void 0;
   } else {
     const roleMarker = profile.roleMarkers[roleSpec.role];
     if (roleMarker) {
       marker = roleMarker.primary;
-      alternatives = roleMarker.alternatives ? [...roleMarker.alternatives] : void 0;
-    }
-  }
-  const variants = roleSpec.markerVariants?.[profile.code];
-  if (variants && variants.length > 0) {
-    const merged = alternatives ? [...alternatives] : [];
-    for (const v of variants) {
-      if (v !== marker && !merged.includes(v)) merged.push(v);
+      const schemaAlts = schemaMarkerAlternatives(roleSpec, profile.code, marker) ?? [];
+      const merged = [.../* @__PURE__ */ new Set([...roleMarker.alternatives ?? [], ...schemaAlts])].filter(
+        (a) => a !== marker
+      );
+      alternatives = merged.length ? merged : void 0;
     }
-    alternatives = merged;
   }
   return { marker, alternatives };
 }
@@ -28931,10 +29188,18 @@ function generateSOVTwoRoleDestFirstEventHandlerPattern(commandSchema, profile,
 var init_event_handlers_sov = __esm({
   "src/generators/event-handlers-sov.ts"() {
     init_command_schemas();
+    init_marker_resolution();
   }
 });
 
 // src/generators/event-handlers-vso.ts
+function mergeSchemaAlternatives(roleSpec, profile, roleMarker) {
+  const schemaAlts = schemaMarkerAlternatives(roleSpec, profile.code, roleMarker.primary) ?? [];
+  const merged = [.../* @__PURE__ */ new Set([...roleMarker.alternatives ?? [], ...schemaAlts])].filter(
+    (a) => a !== roleMarker.primary
+  );
+  return merged.length ? merged : void 0;
+}
 function generateVSOEventHandlerPattern(commandSchema, profile, keyword, eventMarker, config) {
   const tokens = [];
   if (eventMarker.position === "before") {
@@ -29047,11 +29312,12 @@ function generateVSOVerbFirstTwoRoleEventHandlerPattern(commandSchema, profile,
     let markerAlternatives;
     if (roleSpec.markerOverride && roleSpec.markerOverride[profile.code] !== void 0) {
       marker = roleSpec.markerOverride[profile.code];
+      markerAlternatives = marker ? schemaMarkerAlternatives(roleSpec, profile.code, marker) : void 0;
     } else {
       const roleMarker = profile.roleMarkers[roleSpec.role];
       if (roleMarker) {
         marker = roleMarker.primary;
-        markerAlternatives = roleMarker.alternatives;
+        markerAlternatives = mergeSchemaAlternatives(roleSpec, profile, roleMarker);
       }
     }
     if (marker) {
@@ -29104,11 +29370,12 @@ function generateVSOTwoRoleEventHandlerPattern(commandSchema, profile, keyword,
     let markerAlternatives;
     if (roleSpec.markerOverride && roleSpec.markerOverride[profile.code] !== void 0) {
       marker = roleSpec.markerOverride[profile.code];
+      markerAlternatives = marker ? schemaMarkerAlternatives(roleSpec, profile.code, marker) : void 0;
     } else {
       const roleMarker = profile.roleMarkers[roleSpec.role];
       if (roleMarker) {
         marker = roleMarker.primary;
-        markerAlternatives = roleMarker.alternatives;
+        markerAlternatives = mergeSchemaAlternatives(roleSpec, profile, roleMarker);
       }
     }
     if (marker) {
@@ -29241,6 +29508,7 @@ var init_event_handlers_vso = __esm({
   "src/generators/event-handlers-vso.ts"() {
     init_command_schemas();
     init_event_handlers_sov();
+    init_marker_resolution();
   }
 });
 function generatePattern(schema, profile, config = defaultConfig) {
@@ -29613,7 +29881,13 @@ function buildRoleToken(roleSpec, profile) {
     const position = defaultMarker?.position ?? "before";
     const optionalMarker = roleSpec.markerOptional?.[profile.code] === true;
     const pushWord = (word) => {
-      const literal = suppressMarker ? { type: "literal", value: word, renderSuppress: true } : { type: "literal", value: word };
+      const alternatives = markerWords.length === 1 ? schemaMarkerAlternatives(roleSpec, profile.code, word) ?? [] : [];
+      const literal = {
+        type: "literal",
+        value: word,
+        ...alternatives.length ? { alternatives } : {},
+        ...suppressMarker ? { renderSuppress: true } : {}
+      };
       tokens.push(optionalMarker ? { type: "group", optional: true, tokens: [literal] } : literal);
     };
     if (position === "before") {
@@ -29624,10 +29898,12 @@ function buildRoleToken(roleSpec, profile) {
       for (const word of markerWords) pushWord(word);
     }
   } else if (defaultMarker) {
-    const variantAlts = roleSpec.markerVariants?.[profile.code] ?? [];
     const asMarker = () => {
       const alternatives = [
-        .../* @__PURE__ */ new Set([...defaultMarker.alternatives ?? [], ...variantAlts])
+        .../* @__PURE__ */ new Set([
+          ...defaultMarker.alternatives ?? [],
+          ...schemaMarkerAlternatives(roleSpec, profile.code, defaultMarker.primary) ?? []
+        ])
       ].filter((a) => a !== defaultMarker.primary);
       return {
         type: "literal",
@@ -29663,11 +29939,19 @@ function buildExtractionRules(schema, profile) {
     if (roleSpec.valuePrefixLiteral?.[profile.code]) {
       rules[roleSpec.role] = { marker: roleSpec.valuePrefixLiteral[profile.code] };
     } else if (overrideMarker !== void 0) {
-      rules[roleSpec.role] = overrideMarker ? { marker: overrideMarker } : {};
+      if (!overrideMarker) {
+        rules[roleSpec.role] = {};
+      } else {
+        const isSingleWord = !/\s/.test(overrideMarker.trim());
+        const markerAlternatives = isSingleWord ? schemaMarkerAlternatives(roleSpec, profile.code, overrideMarker) ?? [] : [];
+        rules[roleSpec.role] = markerAlternatives.length ? { marker: overrideMarker, markerAlternatives } : { marker: overrideMarker };
+      }
     } else if (defaultMarker && defaultMarker.primary) {
-      const variantAlts = roleSpec.markerVariants?.[profile.code] ?? [];
       const markerAlternatives = [
-        .../* @__PURE__ */ new Set([...defaultMarker.alternatives ?? [], ...variantAlts])
+        .../* @__PURE__ */ new Set([
+          ...defaultMarker.alternatives ?? [],
+          ...schemaMarkerAlternatives(roleSpec, profile.code, defaultMarker.primary) ?? []
+        ])
       ].filter((a) => a !== defaultMarker.primary);
       rules[roleSpec.role] = markerAlternatives.length ? { marker: defaultMarker.primary, markerAlternatives } : { marker: defaultMarker.primary };
     } else {
@@ -31673,6 +31957,9 @@ init_command_schemas();
 // src/utils/confidence-calculator.ts
 init_registry();
 
+// src/explicit/converter.ts
+init_registry();
+
 // src/cache/semantic-cache.ts
 var SemanticCache = class {
   constructor(config = {}) {