@lokascript/compilation-service 2.9.4 → 2.11.0

package/dist/{dist-VGR6QDPB.js → dist-6PFOOXNF.js}

@@ -4219,6 +4219,37 @@ function parseTakeCommand(ctx, identifierNode) {
   }
   return CommandNodeBuilder.fromIdentifier(identifierNode).withArgs(...args).withModifiers(modifiers).endingAt(ctx.getPosition()).build();
 }
+function consumeViewTransitionTail(ctx, args) {
+  if (!ctx.check("using")) {
+    return false;
+  }
+  ctx.advance();
+  if (!ctx.match("view")) {
+    throw new Error("expected 'view transition' after 'using'");
+  }
+  if (!ctx.match("transition")) {
+    throw new Error("expected 'transition' after 'using view'");
+  }
+  args.push(ctx.createIdentifier("using"));
+  args.push(ctx.createIdentifier("view"));
+  args.push(ctx.createIdentifier("transition"));
+  return true;
+}
+function parseProcessCommand(ctx, identifierNode) {
+  if (!ctx.check("partials")) {
+    return null;
+  }
+  const args = [];
+  consumeKeywordToArgs(ctx, "partials", args);
+  if (consumeKeywordToArgs(ctx, KEYWORDS$1.IN, args)) {
+    const contentArg = parseOneArgument(ctx, ["using"]);
+    if (contentArg) {
+      args.push(contentArg);
+    }
+  }
+  consumeViewTransitionTail(ctx, args);
+  return CommandNodeBuilder.fromIdentifier(identifierNode).withArgs(...args).endingAt(ctx.getPosition()).build();
+}
 function parseAddCommand(ctx, commandToken) {
   const args = [];
   if (ctx.match("{")) {
@@ -4326,6 +4357,7 @@ function parseSwapCommand(ctx, identifierNode) {
       args.push(contentExpr);
     }
   }
+  consumeViewTransitionTail(ctx, args);
   return CommandNodeBuilder.fromIdentifier(identifierNode).withArgs(...args).endingAt(ctx.getPosition()).build();
 }
 function parseWaitCommand(ctx, commandToken) {
@@ -4789,6 +4821,8 @@ function parseCompoundCommand(ctx, identifierNode) {
     case "swap":
     case "morph":
       return parseSwapCommand(ctx, identifierNode);
+    case "process":
+      return parseProcessCommand(ctx, identifierNode) ?? parseRegularCommand(ctx, identifierNode);
     default:
       return parseRegularCommand(ctx, identifierNode);
   }
@@ -5101,6 +5135,9 @@ function parseTellCommand(ctx, identifierNode) {
   if (!target) {
     throw new Error("tell command requires a target expression");
   }
+  if (ctx.check(KEYWORDS$1.TO)) {
+    ctx.advance();
+  }
   const commands = [];
   while (!ctx.isAtEnd()) {
     if (ctx.checkIsCommand()) {
@@ -5118,7 +5155,11 @@ function parseTellCommand(ctx, identifierNode) {
       if (ctx.match(KEYWORDS$1.AND) || ctx.match(KEYWORDS$1.THEN)) {
         continue;
       }
-      if (ctx.check(KEYWORDS$1.ELSE) || ctx.check(KEYWORDS$1.END)) {
+      if (ctx.check(KEYWORDS$1.ELSE)) {
+        break;
+      }
+      if (ctx.check(KEYWORDS$1.END)) {
+        ctx.advance();
         break;
       }
       if (ctx.checkIsCommand()) {
@@ -7231,7 +7272,8 @@ var Parser = class _Parser {
       "closest",
       "js",
       "tell",
-      "fetch"
+      "fetch",
+      "process"
     ];
     if (this.semanticAdapter && !skipSemanticParsing.includes(commandName.toLowerCase())) {
       const remainingInput = this.getRemainingInput();
@@ -8149,6 +8191,12 @@ function createChildContext(parent, element) {
 function isHTMLElement$2(value) {
   return value !== null && typeof value === "object" && "nodeType" in value && value.nodeType === 1 && "tagName" in value && typeof value.tagName === "string" && "classList" in value;
 }
+function isInsertableNode(value) {
+  if (value === null || typeof value !== "object")
+    return false;
+  const nodeType = value.nodeType;
+  return nodeType === 1 || nodeType === 3 || nodeType === 11;
+}
 function isNodeList(value) {
   return value !== null && typeof value === "object" && "length" in value && typeof value.length === "number" && (Symbol.iterator in value || typeof value.item === "function");
 }
@@ -9920,6 +9968,11 @@ function evaluateLiteral(node) {
 }
 async function evaluateIdentifier(node, context) {
   const name = node.name;
+  if (name.startsWith("$")) {
+    notifyGlobalRead(name.slice(1), context);
+  } else if (node.scope === "global") {
+    notifyGlobalRead(name, context);
+  }
   if (name === "me" || name === "my" || name === "I") {
     return getExpr(context, "me").evaluate(context);
   }
@@ -9939,7 +9992,6 @@ async function evaluateIdentifier(node, context) {
     return getExpr(context, "document").evaluate(context);
   }
   if (node.scope === "global" && context.globals?.has(name)) {
-    notifyGlobalRead(name, context);
     return context.globals.get(name);
   }
   if (node.scope === "element") {
@@ -9950,12 +10002,9 @@ async function evaluateIdentifier(node, context) {
     return context.locals.get(name);
   }
   if (context.globals && context.globals.has(name)) {
-    if (name.startsWith("$"))
-      notifyGlobalRead(name.slice(1), context);
     return context.globals.get(name);
   }
   if (name.startsWith("$") && context.globals && context.globals.has(name.slice(1))) {
-    notifyGlobalRead(name.slice(1), context);
     return context.globals.get(name.slice(1));
   }
   if (context[name] !== void 0) {
@@ -11196,7 +11245,7 @@ var CommandAdapterV2 = class {
     return {
       description: this.impl.metadata?.description || "",
       examples: this.impl.metadata?.examples || [],
-      syntax: Array.isArray(syntax) ? syntax.join(" | ") : syntax || ""
+      syntax: typeof syntax === "string" ? syntax : syntax ? syntax.join(" | ") : ""
     };
   }
   async execute(context, ...args) {
@@ -11264,10 +11313,8 @@ var CommandAdapterV2 = class {
     }
   }
   validate(input) {
-    if (this.impl.validate) {
-      return this.impl.validate(input);
-    }
-    return { isValid: true, errors: [], suggestions: [] };
+    const isValid = this.impl.validate ? this.impl.validate(input) : true;
+    return { isValid, errors: [], suggestions: [] };
   }
 };
 var CommandRegistryV2 = class {
@@ -15928,7 +15975,7 @@ function command(config2) {
   };
 }
 function commandMeta(metadata) {
-  return { isBlocking: false, hasBody: false, version: "1.0.0", ...metadata };
+  return { ...metadata };
 }
 function createFactory(CommandClass) {
   return () => new CommandClass();
@@ -16793,7 +16840,7 @@ function insertContent(target, content, position) {
     insertReplace(target, content);
     return;
   }
-  if (isHTMLElement$2(content)) {
+  if (isInsertableNode(content)) {
     insertElement(target, content, position);
   } else {
     insertText(target, content, position);
@@ -16803,7 +16850,7 @@ function insertContentSemantic(target, content, position) {
   insertContent(target, content, toInsertPosition(position));
 }
 function insertReplace(target, content) {
-  if (isHTMLElement$2(content)) {
+  if (isInsertableNode(content)) {
     target.innerHTML = "";
     target.appendChild(content);
   } else {
@@ -16847,6 +16894,52 @@ function insertText(target, content, position) {
     target.insertAdjacentText(domPosition, content);
   }
 }
+function moveOrInsert(parent, element, ref) {
+  const p = parent;
+  if (typeof p.moveBefore === "function" && element.isConnected && parent.isConnected) {
+    try {
+      p.moveBefore(element, ref);
+      return;
+    } catch {
+    }
+  }
+  parent.insertBefore(element, ref);
+}
+function insertElementsInOrder(target, elements, position) {
+  switch (position) {
+    case "beforeend":
+      for (const el of elements)
+        moveOrInsert(target, el, null);
+      break;
+    case "afterbegin":
+      for (let i = elements.length - 1; i >= 0; i--) {
+        moveOrInsert(target, elements[i], target.firstChild);
+      }
+      break;
+    case "beforebegin": {
+      const parent = target.parentElement;
+      if (!parent)
+        return;
+      for (const el of elements)
+        moveOrInsert(parent, el, target);
+      break;
+    }
+    case "afterend": {
+      const parent = target.parentElement;
+      if (!parent)
+        return;
+      for (let i = elements.length - 1; i >= 0; i--) {
+        moveOrInsert(parent, elements[i], target.nextSibling);
+      }
+      break;
+    }
+    case "replace":
+      target.innerHTML = "";
+      for (const el of elements)
+        moveOrInsert(target, el, null);
+      break;
+  }
+}
 function removeElement(element) {
   if (element.parentNode) {
     element.remove();
@@ -17876,7 +17969,11 @@ var PutCommand = (() => {
       } else {
         for (const t of targets) {
           const content = this.parseValue(value);
-          insertContentSemantic(t, content, position);
+          if (Array.isArray(content)) {
+            insertElementsInOrder(t, content, toInsertPosition(position));
+          } else {
+            insertContentSemantic(t, content, position);
+          }
         }
       }
       return targets;
@@ -17908,6 +18005,11 @@ var PutCommand = (() => {
     parseValue(v2) {
       if (isHTMLElement$2(v2))
         return v2;
+      if (Array.isArray(v2) && v2.length > 0 && v2.every(isHTMLElement$2)) {
+        return v2;
+      }
+      if (isInsertableNode(v2))
+        return v2;
       return v2 == null ? "" : String(v2);
     }
     looksLikeCss(s) {
@@ -19104,7 +19206,8 @@ var morphAdapter = {
 function getStartViewTransition() {
   if (typeof document === "undefined")
     return void 0;
-  return document.startViewTransition;
+  const fn = document.startViewTransition;
+  return typeof fn === "function" ? fn.bind(document) : void 0;
 }
 function isViewTransitionsSupported() {
   return typeof getStartViewTransition() === "function";
@@ -19341,7 +19444,7 @@ var SwapCommand = (() => {
           };
         }
       }
-      let useViewTransition = false;
+      let useViewTransition = raw.modifiers?.viewTransition !== void 0;
       if (usingIndex !== -1) {
         const afterUsing = argKeywords.slice(usingIndex + 1);
         if (afterUsing.includes("view") && afterUsing.includes("transition")) {
@@ -19537,7 +19640,7 @@ var MorphCommand = (() => {
       const withIndex = argKeywords.findIndex((k) => k === "with");
       const overIndex = argKeywords.findIndex((k) => k === "over");
       const usingIndex = argKeywords.findIndex((k) => k === "using");
-      let useViewTransition = false;
+      let useViewTransition = raw.modifiers?.viewTransition !== void 0;
       if (usingIndex !== -1) {
         const afterUsing = argKeywords.slice(usingIndex + 1);
         if (afterUsing.includes("view") && afterUsing.includes("transition")) {
@@ -19613,7 +19716,11 @@ var MorphCommand = (() => {
   })();
   _classThis.metadata = commandMeta({
     description: "Morph content into target elements (intelligent diffing, preserves state)",
-    syntax: ["morph <target> with <content>", "morph over <target> with <content>"],
+    syntax: [
+      "morph <target> with <content>",
+      "morph over <target> with <content>",
+      "morph <target> with <content> using view transition"
+    ],
     examples: ["morph #target with it", "morph over #modal with fetchedContent"],
     sideEffects: ["dom-mutation"],
     category: "dom",
@@ -20237,24 +20344,32 @@ var ProcessPartialsCommand = (() => {
       if (!args || args.length === 0) {
         throw new Error("process partials command requires content argument");
       }
-      const evaluatedArgs = [];
-      const argStrings = [];
-      for (const arg of args) {
-        const evaluated = await evaluator.evaluate(arg, context);
-        evaluatedArgs.push(evaluated);
-        if (typeof evaluated === "string") {
-          argStrings.push(evaluated.toLowerCase());
-        }
-      }
-      const partialsIndex = argStrings.findIndex((s) => s === "partials");
+      const keywordOf = (node) => {
+        const n = node;
+        if (!n || typeof n !== "object")
+          return null;
+        if (n.type === "identifier" && typeof n.name === "string")
+          return n.name.toLowerCase();
+        if (n.type === "literal" && typeof n.value === "string")
+          return n.value.toLowerCase();
+        return null;
+      };
+      const keywords = args.map(keywordOf);
+      const partialsIndex = keywords.indexOf("partials");
+      const inIndex = keywords.indexOf("in");
+      let contentNode;
       if (partialsIndex === -1) {
-        throw new Error('process command expects "partials" keyword: process partials in <content>');
-      }
-      const inIndex = argStrings.findIndex((s) => s === "in");
-      if (inIndex === -1 || inIndex <= partialsIndex) {
-        throw new Error('process partials command expects "in" keyword: process partials in <content>');
+        if (inIndex !== -1) {
+          throw new Error('process command expects "partials" keyword: process partials in <content>');
+        }
+        contentNode = args[0];
+      } else {
+        if (inIndex === -1 || inIndex <= partialsIndex) {
+          throw new Error('process partials command expects "in" keyword: process partials in <content>');
+        }
+        contentNode = args[inIndex + 1];
       }
-      const contentArg = evaluatedArgs[inIndex + 1];
+      const contentArg = contentNode ? await evaluator.evaluate(contentNode, context) : void 0;
       let html;
       if (typeof contentArg === "string") {
         html = contentArg;
@@ -20265,10 +20380,10 @@ var ProcessPartialsCommand = (() => {
       } else {
         throw new Error("process partials: content must be an HTML string or element");
       }
-      const usingIndex = argStrings.findIndex((s) => s === "using");
-      let useViewTransition = false;
+      let useViewTransition = raw.modifiers?.viewTransition !== void 0;
+      const usingIndex = keywords.indexOf("using");
       if (usingIndex !== -1) {
-        const remaining = argStrings.slice(usingIndex + 1).join(" ");
+        const remaining = keywords.slice(usingIndex + 1);
         if (remaining.includes("view") && remaining.includes("transition")) {
           useViewTransition = true;
         }
@@ -25863,6 +25978,7 @@ var Runtime = class extends RuntimeBase {
     return this.registry;
   }
 };
+var VERSION$1 = "2.10.0";
 function createLiteral$1(value, dataType) {
   return dataType ? { type: "literal", value, dataType } : { type: "literal", value };
 }
@@ -30140,14 +30256,26 @@ var MultilingualDSLImpl = class {
   }
   translate(input, fromLanguage, toLanguage) {
     if (isExplicitSyntax$1(input)) return input;
-    for (const language of [fromLanguage, toLanguage]) {
-      if (!this.profileProvider.getProfile(language)) {
-        throw new Error(
-          `translate() requires a grammar profile for language "${language}", but none is configured. Set 'grammarProfile' on the LanguageConfig for "${language}" in createMultilingualDSL() (parse/validate/compile do not need it), or inject a custom 'profileProvider'.`
-        );
+    let node;
+    try {
+      node = this.parseWithConfidence(input, fromLanguage).node;
+    } catch (parseError) {
+      if (this.hasGrammarProfile(fromLanguage) && this.hasGrammarProfile(toLanguage)) {
+        return this.transformer.transform(input, fromLanguage, toLanguage);
       }
+      throw parseError;
+    }
+    const rendered = this.registry.getSupportedLanguages().includes(toLanguage) ? this.render(node, toLanguage) : null;
+    if (rendered != null) return rendered;
+    if (this.hasGrammarProfile(fromLanguage) && this.hasGrammarProfile(toLanguage)) {
+      return this.transformer.transform(input, fromLanguage, toLanguage);
     }
-    return this.transformer.transform(input, fromLanguage, toLanguage);
+    throw new Error(
+      `translate() could not render action "${node.action}" in language "${toLanguage}": no custom renderer, domain renderer, or schema pattern covers it, and no grammar profile is configured for the transformer fallback. Either add "${toLanguage}" to the DSL's languages/renderer, or set 'grammarProfile' on its LanguageConfig in createMultilingualDSL() (parse/validate/compile do not need it).`
+    );
+  }
+  hasGrammarProfile(language) {
+    return this.profileProvider.getProfile(language) != null;
   }
   compile(input, language) {
     if (!this.codeGenerator) {
@@ -34400,6 +34528,8 @@ var initSchema;
 var behaviorSchema;
 var installSchema;
 var measureSchema;
+var USING_VIEW_MARKER_ALL_LANGS;
+var VIEW_TRANSITION_MANNER_ROLE;
 var swapSchema;
 var morphSchema;
 var beepSchema;
@@ -34422,7 +34552,6 @@ var init_command_schemas = __esm({
       category: "dom-class",
       primaryRole: "patient",
       // `toggle .active on #btn for 2s` \u2192 args ['.active'], modifiers { on, for }.
-      // NOTE: `duration` is read here but not declared in `roles` below.
       ast: { args: ["patient"], modifiers: { on: "destination", for: "duration" } },
       roles: [
         {
@@ -34432,7 +34561,13 @@ var init_command_schemas = __esm({
           expectedTypes: ["selector"],
           selectorKinds: ["class", "attribute"],
           svoPosition: 1,
-          sovPosition: 2
+          sovPosition: 2,
+          // zh: the transformer emits `\u5207\u6362 \u628a .active` (the profile's \u628a patient
+          // marker), but natural zh writes `\u5207\u6362 .active` bare \u2014 the handcrafted
+          // patterns' form. Optional accepts both; without it the generated
+          // pattern REQUIRED \u628a and the slim bundles could not parse the bare
+          // form at all. Same treatment as go's destination.
+          markerOptional: { zh: true }
         },
         {
           role: "destination",
@@ -34770,6 +34905,8 @@ var init_command_schemas = __esm({
           markerOverride: {
             en: "",
             // No marker before destination in English: "set :x to 5"
+            es: "",
+            // "establecer x a 5" - no marker before variable (profile default `en` matched nothing)
             ja: "\u3092",
             // "x \u3092 10 \u306b \u8a2d\u5b9a" - variable gets object marker
             ko: "\uB97C",
@@ -34792,9 +34929,19 @@ var init_command_schemas = __esm({
             // generated hi set patterns carried the swapped markers and matched no
             // corpus, so the whole hi set-family (set-text/inner-html/style/attribute)
             // fell to the bare-event fallback (S6 set-trio).
-            hi: "\u0915\u094B"
+            hi: "\u0915\u094B",
             // target (destination) gets \u0915\u094b
-          }
+            // zh: the transformer emits the verb-first BA form `\u8bbe\u7f6e \u628a X \u5230 V`
+            // (\u628a before the variable), while natural zh writes `\u8bbe\u7f6e X \u4e3a V`
+            // (unmarked). \u628a as the marker, optional below, accepts both. The
+            // profile default \u5728 matched neither form, so the generated zh set
+            // patterns were dead weight and the slim bundles (schema-generated
+            // patterns only) could not parse set at all.
+            zh: "\u628A"
+          },
+          // Accept the unmarked natural form alongside the transformer's \u628a form
+          // (same treatment as go's destination).
+          markerOptional: { zh: true }
         },
         {
           role: "patient",
@@ -34837,8 +34984,14 @@ var init_command_schemas = __esm({
             // "x \u0995\u09c7 10 \u09a4\u09c7 \u09b8\u09c7\u099f" - destination marker on value
             qu: "man",
             // "x ta 10 man churay" - destination marker on value
-            hi: "\u092E\u0947\u0902"
+            hi: "\u092E\u0947\u0902",
             // value (patient) gets \u092e\u0947\u0902 \u2014 see the destination note above
+            // zh: the transformer/corpus form marks the value with \u5230 (`\u8bbe\u7f6e \u628a X
+            // \u5230 V`); natural zh uses \u4e3a (`\u8bbe\u7f6e X \u4e3a V`). \u5230 is the override,
+            // the \u4e3a-family rides along as variants (all merged as alternatives
+            // by schemaMarkerAlternatives). Profile default \u628a was the PATIENT
+            // marker, which never precedes set's value in either form.
+            zh: "\u5230"
           },
           // Turkish dative is allomorphic under vowel harmony: the i18n transformer
           // emits `e` for quoted-string values (`"red" e`) but `-ya` for a value
@@ -34851,7 +35004,11 @@ var init_command_schemas = __esm({
           // not parse as a bare command while `t\u0131klama da @disabled i do\u011fru ya
           // ayarla` did. See STRUCTURAL_ARCS_ROADMAP.md (tr set-attribute).
           markerVariants: {
-            tr: ["e", "a", "ye", "ya"]
+            tr: ["e", "a", "ye", "ya"],
+            // Natural zh value markers (`\u8bbe\u7f6e X \u4e3a V`), simplified + traditional +
+            // resultative \u2014 the handcrafted set-zh-full alternatives, kept parseable
+            // alongside the transformer's \u5230 override above.
+            zh: ["\u4E3A", "\u70BA", "\u6210"]
           }
         },
         {
@@ -35513,8 +35670,8 @@ var init_command_schemas = __esm({
       description: "Take content from a source element",
       category: "dom-content",
       primaryRole: "patient",
-      // `take .active from #parent` \u2192 args ['.active'], modifiers { from: '#parent' }.
-      ast: { args: ["patient"], modifiers: { from: "source" } },
+      // `take .active from #parent for me` \u2192 args ['.active'], modifiers { from, for }.
+      ast: { args: ["patient"], modifiers: { from: "source", for: "recipient" } },
       roles: [
         {
           role: "patient",
@@ -35537,6 +35694,38 @@ var init_command_schemas = __esm({
           expectedTypes: ["selector", "reference"],
           svoPosition: 2,
           sovPosition: 1
+        },
+        {
+          role: "recipient",
+          description: "The element the class moves ONTO (`take .active from .tab for me`)",
+          required: false,
+          // References only, deliberately. Upstream accepts an element expression,
+          // but the 23 non-en corpus surfaces carry the recipient as a BARE
+          // trailing pronoun (i18n renders `\u2026 von .tab-button ich`), so this slot
+          // is marker-less almost everywhere and a selector-typed slot would
+          // swallow the second selector of `take .active from .a .b`. English is
+          // unaffected: `take` is on the core parser's skipSemanticParsing list,
+          // so the traditional parser owns `for <anything>` there.
+          expectedTypes: ["reference"],
+          svoPosition: 3,
+          sovPosition: 3,
+          // NO default. The runtime already defaults the recipient to `me`
+          // (commands/animation/take.ts), and a schema default would emit an
+          // explicit `for me` modifier on every take \u2014 re-smuggling the exact
+          // "absent means absent" semantics #859 removed from `source`.
+          //
+          // Shape-anchored on `reference`: without it this optional slot weighs
+          // into every take pattern's denominator in `scoreRoleCoverage`, dropping
+          // plain `take .active from .tab-button` from 1.0 to ~0.69 \u2014 the toggle-es
+          // regression class the R1 role-set flip ratchet exists to catch.
+          valueShape: "reference",
+          // en only. The other 23 languages render the recipient unmarked, so a
+          // marker there would never match their corpus rows; where the marker-less
+          // slot proves inert they stay uncaptured and the pattern lands in the
+          // baseline's `roleLossyPatterns` as named R1 burn-down tail. A language
+          // gets a real particle here ONLY if the empty slot perturbs its other
+          // parses (toggle's ja \u9593 / ko \ub3d9\uc548 case).
+          markerOverride: { en: "for" }
         }
       ]
     };
@@ -36601,6 +36790,47 @@ var init_command_schemas = __esm({
         }
       ]
     };
+    USING_VIEW_MARKER_ALL_LANGS = {
+      en: "using view",
+      es: "using view",
+      pt: "using view",
+      fr: "using view",
+      de: "using view",
+      it: "using view",
+      ja: "using view",
+      ko: "using view",
+      zh: "using view",
+      ar: "using view",
+      he: "using view",
+      hi: "using view",
+      bn: "using view",
+      tr: "using view",
+      ru: "using view",
+      uk: "using view",
+      pl: "using view",
+      id: "using view",
+      vi: "using view",
+      th: "using view",
+      ms: "using view",
+      tl: "using view",
+      sw: "using view",
+      qu: "using view"
+    };
+    VIEW_TRANSITION_MANNER_ROLE = {
+      role: "manner",
+      description: "Run the swap inside a `document.startViewTransition()` (`using view transition`)",
+      required: false,
+      // Both types, because the SAME word tokenizes differently per language and
+      // the difference is an accident of vocabulary: `transition` is a command
+      // keyword in en/fr (it is also their verb) and a bare identifier everywhere
+      // else, which types it `literal` in the first group and `expression` in the
+      // second. Measured: with `['literal']` alone only en and fr captured the
+      // tail. Widening is safe precisely because the slot is marker-guarded \u2014
+      // nothing reaches it until `using view` has matched.
+      expectedTypes: ["literal", "expression"],
+      valueShape: "keyword",
+      markerOverride: USING_VIEW_MARKER_ALL_LANGS
+    };
     swapSchema = {
       action: "swap",
       description: "Swap DOM content using various strategies (innerHTML, outerHTML, delete, etc.)",
@@ -36621,7 +36851,11 @@ var init_command_schemas = __esm({
       // work. Preserved verbatim by the Arc F migration (a faithful migration must
       // not change output) and pinned as two `drift` exemptions; this is the
       // behavior fix those entries were waiting for.
-      ast: { args: ["method", "destination", "patient"] },
+      //
+      // `manner` is the exception to "keyword-positional args": it rides as
+      // `modifiers.viewTransition`, which SwapCommand.parseInput reads for presence
+      // alongside its existing flat-args `using`/`view`/`transition` scan.
+      ast: { args: ["method", "destination", "patient"], modifiers: { viewTransition: "manner" } },
       roles: [
         {
           role: "method",
@@ -36716,6 +36950,11 @@ var init_command_schemas = __esm({
             ar: "\u0628\u0640",
             tl: "nang"
           }
+        },
+        {
+          ...VIEW_TRANSITION_MANNER_ROLE,
+          svoPosition: 4,
+          sovPosition: 4
         }
       ]
     };
@@ -36726,7 +36965,15 @@ var init_command_schemas = __esm({
       primaryRole: "patient",
       // `morph #list to it` \u2192 args [content], modifiers { on: element }.
       // Content is source or destination; the element being morphed is the patient.
-      ast: { args: [["source", "destination"]], modifiers: { on: "patient" } },
+      //
+      // `manner` rides as `modifiers.viewTransition`, same as swap/process \u2014
+      // MorphCommand.parseInput reads it for presence alongside its existing
+      // flat-args `using`/`view`/`transition` scan (the traditional-parser path,
+      // which owns English because morph sits on SKIP_SEMANTIC_COMMANDS).
+      ast: {
+        args: [["source", "destination"]],
+        modifiers: { on: "patient", viewTransition: "manner" }
+      },
       roles: [
         {
           role: "patient",
@@ -36747,6 +36994,18 @@ var init_command_schemas = __esm({
           sovPosition: 2,
           markerOverride: { en: "to" }
           // "morph #target to it"
+        },
+        {
+          // `morph #target to it using view transition` \u2014 the same tail as swap and
+          // process, closed here for the same reason (#870's third-schema filing):
+          // without the role the semantic parser matched morph at confidence 1.0
+          // and stranded the tail, so every semantic-only consumer (multilingual
+          // bundles, the bridge, `translate()`) silently dropped the animation
+          // request in all 24 languages. Morph has NO hand-written patterns in any
+          // language, so this schema role is the whole fix on the pattern side.
+          ...VIEW_TRANSITION_MANNER_ROLE,
+          svoPosition: 3,
+          sovPosition: 3
         }
       ]
     };
@@ -36933,6 +37192,13 @@ var init_command_schemas = __esm({
       description: "Process hx-partial markup in HTML content",
       category: "dom-content",
       primaryRole: "patient",
+      // `process partials in it` \u2192 args ['it']; the optional tail rides as
+      // `modifiers.viewTransition`, which ProcessPartialsCommand.parseInput has
+      // read since #861 (`raw.modifiers?.viewTransition !== undefined`). Without a
+      // descriptor this schema fell through to `buildGenericCommand`, whose
+      // modifier list is fixed (destination/duration/method/style) and would have
+      // dropped a captured `manner` on the floor.
+      ast: { args: ["patient"], modifiers: { viewTransition: "manner" } },
       roles: [
         {
           role: "patient",
@@ -36942,6 +37208,11 @@ var init_command_schemas = __esm({
           svoPosition: 1,
           sovPosition: 1,
           markerOverride: PARTIALS_IN_MARKER_ALL_LANGS
+        },
+        {
+          ...VIEW_TRANSITION_MANNER_ROLE,
+          svoPosition: 2,
+          sovPosition: 2
         }
       ]
     };
@@ -38526,7 +38797,9 @@ var init_french = __esm({
         trigger: { primary: "d\xE9clencher", normalized: "trigger" },
         send: { primary: "envoyer", alternatives: ["envoie"], normalized: "send" },
         focus: { primary: "focaliser", alternatives: ["concentrer"], normalized: "focus" },
-        blur: { primary: "d\xE9focaliser", normalized: "blur" },
+        // `d\u00e9focaliser` is an unattested infinitive; French pedagogy writes
+        // `perte de focus` for the event (2026-07 terminology review).
+        blur: { primary: "perte de focus", alternatives: ["d\xE9focaliser"], normalized: "blur" },
         // Phase 1 (v0.9.90): DOM / form state / debug
         // `vide` (adjective, "empty") is the i18n transformer's `is empty` predicate
         // form; `vider` is the verb ("to empty"). Accept both so the emptiness check
@@ -38539,7 +38812,13 @@ var init_french = __esm({
         reset: { primary: "r\xE9initialiser", alternatives: ["reinitialiser"], normalized: "reset" },
         breakpoint: { primary: "point-arr\xEAt", alternatives: ["point-arret"], normalized: "breakpoint" },
         go: { primary: "aller", alternatives: ["naviguer", "va"], normalized: "go" },
-        scroll: { primary: "d\xE9filer", alternatives: ["faire-d\xE9filer"], normalized: "scroll" },
+        // MDN fr and the OQLF standardize the noun `d\u00e9filement` for the event; the
+        // infinitive stays as an alternative.
+        scroll: {
+          primary: "d\xE9filement",
+          alternatives: ["defilement", "d\xE9filer", "faire-d\xE9filer"],
+          normalized: "scroll"
+        },
         push: { primary: "pousser", normalized: "push" },
         replace: { primary: "remplacer", normalized: "replace" },
         process: { primary: "traiter", normalized: "process" },
@@ -38605,9 +38884,15 @@ var init_french = __esm({
         after: { primary: "apr\xE8s", normalized: "after" },
         // Common event names (for event handler patterns)
         click: { primary: "clic", alternatives: ["clique"], normalized: "click" },
-        // `resize` event (window-resize): dict emits redimensionner; register it so the
-        // event types as literal="resize" (matching en) instead of expression.
-        resize: { primary: "redimensionner", normalized: "resize" },
+        // `resize` event (window-resize): the noun `redimensionnement` is the
+        // attested event form ("lors du redimensionnement de la fen\u00eatre"). The dict
+        // still emits redimensionner, kept as an alternative so the event keeps
+        // typing as literal="resize" (matching en) instead of expression.
+        resize: {
+          primary: "redimensionnement",
+          alternatives: ["redimensionner"],
+          normalized: "resize"
+        },
         hover: { primary: "survol", alternatives: ["survoler"], normalized: "hover" },
         submit: { primary: "soumission", alternatives: ["soumettre"], normalized: "submit" },
         input: { primary: "saisie", alternatives: ["entr\xE9e"], normalized: "input" },
@@ -42360,9 +42645,17 @@ var init_turkish = __esm({
         on: { primary: "\xFCzerinde", alternatives: ["zaman"], normalized: "on" },
         trigger: { primary: "tetikle", normalized: "trigger" },
         send: { primary: "g\xF6nder", normalized: "send" },
-        // DOM focus
-        focus: { primary: "odak", alternatives: ["odaklanma"], normalized: "focus" },
-        blur: { primary: "bulan\u0131k", alternatives: ["bulan\u0131kl\u0131k", "bulanik"], normalized: "blur" },
+        // DOM focus. `odaklanma` (the act of focusing) leads over the static state
+        // noun `odak` \u2014 Turkish event prose says "odaklanma olay\u0131". `bulan\u0131k` was
+        // the optical blur (CSS filters, image processing), never the DOM event;
+        // native usage is `odak kayb\u0131` (loss of focus). 2026-07 terminology-review
+        // corrections; old forms stay as parse alternatives.
+        focus: { primary: "odaklanma", alternatives: ["odak"], normalized: "focus" },
+        blur: {
+          primary: "odak kayb\u0131",
+          alternatives: ["odak kaybi", "bulan\u0131k", "bulan\u0131kl\u0131k", "bulanik"],
+          normalized: "blur"
+        },
         // Phase 1 (v0.9.90): DOM / form state / debug
         empty: { primary: "bo\u015Falt", alternatives: ["bosalt", "bo\u015F"], normalized: "empty" },
         open: { primary: "a\xE7", alternatives: ["ac"], normalized: "open" },
@@ -42383,7 +42676,9 @@ var init_turkish = __esm({
         },
         hover: { primary: "\xFCzerine gelme", alternatives: ["\xFCzerinde gezinme"], normalized: "hover" },
         submit: { primary: "g\xF6nderme", normalized: "submit" },
-        input: { primary: "giri\u015F", alternatives: ["girdi", "giris"], normalized: "input" },
+        // `giri\u015f` reads as entry/login (giri\u015f yapma) and can imply an auth event;
+        // the data-input term is `girdi` ("Girdi (Input) Eventleri").
+        input: { primary: "girdi", alternatives: ["giri\u015F", "giris"], normalized: "input" },
         change: { primary: "de\u011Fi\u015Fiklik", alternatives: ["de\u011Fi\u015Fim", "degisim"], normalized: "change" },
         // `load` event: the i18n dict emits y\u00fckle for `load`. Without this keyword the
         // SOV reorder's mid-stream `y\u00fckle de` (on load) tokenized as the `install`
@@ -42393,7 +42688,13 @@ var init_turkish = __esm({
         load: { primary: "y\xFCkle", normalized: "load" },
         // Navigation
         go: { primary: "git", normalized: "go" },
-        scroll: { primary: "kayd\u0131r", alternatives: ["kaydir"], normalized: "scroll" },
+        // `kayd\u0131r` is the bare imperative; the attested event noun is `kayd\u0131rma`
+        // ("kayd\u0131rma olay\u0131"). The imperative stays as an alternative.
+        scroll: {
+          primary: "kayd\u0131rma",
+          alternatives: ["kaydirma", "kayd\u0131r", "kaydir"],
+          normalized: "scroll"
+        },
         push: { primary: "itele", alternatives: ["push"], normalized: "push" },
         replace: { primary: "de\u011Fi\u015Ftir_url", alternatives: ["degistir_url"], normalized: "replace" },
         process: { primary: "i\u015Fle", alternatives: ["isle"], normalized: "process" },
@@ -43339,6 +43640,58 @@ var init_chinese = __esm({
     };
   }
 });
+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
+    };
+  }
+  if (defaultMarker && defaultMarker.primary) {
+    const result = {
+      primary: defaultMarker.primary,
+      position: defaultMarker.position,
+      isOverride: false
+    };
+    if (defaultMarker.alternatives) {
+      result.alternatives = defaultMarker.alternatives;
+    }
+    return result;
+  }
+  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 ROLE_MARKER_CONCEPTS;
+var init_marker_resolution = __esm({
+  "src/parser/utils/marker-resolution.ts"() {
+    ROLE_MARKER_CONCEPTS = /* @__PURE__ */ new Set([
+      "destination",
+      "source",
+      "patient",
+      "object",
+      "event",
+      "eventmarker",
+      "manner",
+      "instrument"
+    ]);
+  }
+});
 function getPutPatternsBn() {
   return [
     // SOV verb-final positional put: `{patient} <posWord> {destination} \u0995\u09c7 \u09b0\u09be\u0996\u09c1\u09a8`
@@ -58214,47 +58567,6 @@ var init_role_positioning = __esm({
   "src/parser/utils/role-positioning.ts"() {
   }
 });
-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
-    };
-  }
-  if (defaultMarker && defaultMarker.primary) {
-    const result = {
-      primary: defaultMarker.primary,
-      position: defaultMarker.position,
-      isOverride: false
-    };
-    if (defaultMarker.alternatives) {
-      result.alternatives = defaultMarker.alternatives;
-    }
-    return result;
-  }
-  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"() {
-  }
-});
 function resolveRoleMarker(roleSpec, profile) {
   let marker;
   let alternatives;
@@ -58287,6 +58599,44 @@ function appendOptionalScope(tokens, extraction, commandSchema) {
   });
   extraction.scope = { fromRole: "scope" };
 }
+function appendOptionalViewTransition(tokens, extraction, commandSchema, languageCode) {
+  appendOptionalTailRole(tokens, extraction, commandSchema, languageCode, "manner", {
+    requireMarker: true
+  });
+}
+function appendOptionalRecipient(tokens, extraction, commandSchema, languageCode) {
+  appendOptionalTailRole(tokens, extraction, commandSchema, languageCode, "recipient", {
+    requireMarker: false
+  });
+}
+function appendOptionalTailRole(tokens, extraction, commandSchema, languageCode, role, opts) {
+  const spec = commandSchema.roles.find((r) => r.role === role && !r.required);
+  if (!spec) return;
+  const marker = spec.markerOverride?.[languageCode];
+  if (opts.requireMarker && !marker) return;
+  tokens.push({
+    type: "group",
+    optional: true,
+    tokens: [
+      ...(marker ? marker.split(/\s+/) : []).map((word) => ({
+        type: "literal",
+        value: word
+      })),
+      {
+        type: "role",
+        role,
+        optional: true,
+        expectedTypes: spec.expectedTypes,
+        // Load-bearing, same as on the generated command patterns: it exempts
+        // the trailing slot from the matcher's verb guard, keeps the uncaptured
+        // slot out of `scoreRoleCoverage`'s denominator, and (for `keyword`)
+        // normalizes the captured value type to the EN reference's `literal`.
+        ...spec.valueShape !== void 0 ? { valueShape: spec.valueShape } : {}
+      }
+    ]
+  });
+  extraction[role] = { fromRole: role };
+}
 function generateSOVEventHandlerPattern(commandSchema, profile, keyword, eventMarker, config2) {
   const tokens = [];
   tokens.push({ type: "role", role: "event", optional: false });
@@ -58381,6 +58731,15 @@ function generateSOVPatientFirstEventHandlerPattern(commandSchema, profile, keyw
   tokens.push(
     ...swapsOperands ? eventHandlerPatientGroup(commandSchema, trailingMarker) : eventHandlerDestinationGroup(commandSchema, trailingMarker)
   );
+  const extraction = {
+    action: { value: commandSchema.action },
+    event: { fromRole: "event" },
+    [frontedRole]: { fromRole: frontedRole },
+    ...swapsOperands ? {} : eventHandlerDestinationExtraction(commandSchema),
+    ...eventHandlerSourceExtraction(commandSchema)
+  };
+  appendOptionalRecipient(tokens, extraction, commandSchema, profile.code);
+  appendOptionalViewTransition(tokens, extraction, commandSchema, profile.code);
   return {
     id: `${commandSchema.action}-event-${profile.code}-sov-patient-first`,
     language: profile.code,
@@ -58390,13 +58749,71 @@ function generateSOVPatientFirstEventHandlerPattern(commandSchema, profile, keyw
       format: `{patient} ${patientMarker?.primary || ""} {event} ${eventMarker.primary} ${keyword.primary}`,
       tokens
     },
-    extraction: {
-      action: { value: commandSchema.action },
-      event: { fromRole: "event" },
-      [frontedRole]: { fromRole: frontedRole },
-      ...swapsOperands ? {} : eventHandlerDestinationExtraction(commandSchema),
-      ...eventHandlerSourceExtraction(commandSchema)
+    extraction
+  };
+}
+function generateSOVPatientFirstSourceFrontedEventHandlerPattern(commandSchema, profile, keyword, eventMarker, config2) {
+  const sourceSpec = commandSchema.roles.find((r) => r.role === "source");
+  if (!sourceSpec) return null;
+  const { marker: sourceMarker, alternatives: sourceAlts } = resolveRoleMarker(sourceSpec, profile);
+  const patientMarker = profile.roleMarkers.patient;
+  if (!sourceMarker) return null;
+  if (sourceMarker === eventMarker.primary || sourceMarker === patientMarker?.primary) return null;
+  const tokens = [];
+  tokens.push({ type: "role", role: "patient", optional: false });
+  if (patientMarker) {
+    tokens.push(
+      patientMarker.alternatives ? {
+        type: "literal",
+        value: patientMarker.primary,
+        alternatives: patientMarker.alternatives
+      } : { type: "literal", value: patientMarker.primary }
+    );
+  }
+  tokens.push({
+    type: "role",
+    role: "source",
+    optional: false,
+    ...sourceSpec.expectedTypes ? { expectedTypes: sourceSpec.expectedTypes } : {},
+    ...sourceSpec.valueShape !== void 0 ? { valueShape: sourceSpec.valueShape } : {}
+  });
+  for (const word of sourceMarker.split(/\s+/)) {
+    tokens.push(
+      sourceAlts && sourceMarker.split(/\s+/).length === 1 ? { type: "literal", value: word, alternatives: sourceAlts } : { type: "literal", value: word }
+    );
+  }
+  tokens.push({ type: "role", role: "event", optional: false });
+  if (eventMarker.position === "after") {
+    const markerWords = eventMarker.primary.split(/\s+/);
+    if (markerWords.length > 1) {
+      for (const word of markerWords) tokens.push({ type: "literal", value: word });
+    } else {
+      tokens.push(
+        eventMarker.alternatives ? { type: "literal", value: eventMarker.primary, alternatives: eventMarker.alternatives } : { type: "literal", value: eventMarker.primary }
+      );
     }
+  }
+  tokens.push(
+    keyword.alternatives ? { type: "literal", value: keyword.primary, alternatives: keyword.alternatives } : { type: "literal", value: keyword.primary }
+  );
+  const extraction = {
+    action: { value: commandSchema.action },
+    event: { fromRole: "event" },
+    patient: { fromRole: "patient" },
+    source: { fromRole: "source" }
+  };
+  appendOptionalRecipient(tokens, extraction, commandSchema, profile.code);
+  appendOptionalViewTransition(tokens, extraction, commandSchema, profile.code);
+  return {
+    id: `${commandSchema.action}-event-${profile.code}-sov-source-fronted`,
+    language: profile.code,
+    command: "on",
+    priority: (config2.basePriority ?? 100) + 48,
+    template: {
+      format: `{patient} ${patientMarker?.primary || ""} {source} ${sourceMarker} {event} ${eventMarker.primary} ${keyword.primary}`,
+      tokens
+    },
+    extraction
   };
 }
 function generateSOVPatientFirstWithDestEventHandlerPattern(commandSchema, profile, keyword, eventMarker, config2) {
@@ -58836,6 +59253,16 @@ function generateVSOVerbFirstEventHandlerPattern(commandSchema, profile, keyword
       });
     }
   }
+  const extraction = {
+    action: { value: commandSchema.action },
+    event: { fromRole: "event" },
+    [swapsOperands ? "destination" : "patient"]: {
+      fromRole: swapsOperands ? "destination" : "patient"
+    },
+    ...swapsOperands ? {} : eventHandlerDestinationExtraction(commandSchema),
+    ...eventHandlerSourceExtraction(commandSchema)
+  };
+  appendOptionalViewTransition(tokens, extraction, commandSchema, profile.code);
   return {
     id: `${commandSchema.action}-event-${profile.code}-vso-verb-first`,
     language: profile.code,
@@ -58846,15 +59273,7 @@ function generateVSOVerbFirstEventHandlerPattern(commandSchema, profile, keyword
       format: `${keyword.primary} {patient} ${destMarker?.primary || ""} {destination?} ${eventMarker.primary} {event}`,
       tokens
     },
-    extraction: {
-      action: { value: commandSchema.action },
-      event: { fromRole: "event" },
-      [swapsOperands ? "destination" : "patient"]: {
-        fromRole: swapsOperands ? "destination" : "patient"
-      },
-      ...swapsOperands ? {} : eventHandlerDestinationExtraction(commandSchema),
-      ...eventHandlerSourceExtraction(commandSchema)
-    }
+    extraction
   };
 }
 function generateVSOVerbFirstTwoRoleEventHandlerPattern(commandSchema, profile, keyword, eventMarker, config2) {
@@ -59295,6 +59714,14 @@ function generateEventHandlerPatterns(commandSchema, profile, config2 = defaultC
           config2
         )
       );
+      const sourceFronted = generateSOVPatientFirstSourceFrontedEventHandlerPattern(
+        commandSchema,
+        profile,
+        keyword,
+        eventMarker,
+        config2
+      );
+      if (sourceFronted) patterns.push(sourceFronted);
       const destMarkerCheck = profile.roleMarkers.destination;
       if (destMarkerCheck && destMarkerCheck.primary !== eventMarker.primary) {
         patterns.push(
@@ -59454,7 +59881,11 @@ function buildRoleToken(roleSpec, profile) {
     type: "role",
     role: roleSpec.role,
     optional: !roleSpec.required,
-    expectedTypes: roleSpec.expectedTypes
+    expectedTypes: roleSpec.expectedTypes,
+    // The matcher reads this too \u2014 a `'keyword'`-shaped slot holds a fixed
+    // keyword phrase (`using view transition`) and must not be skipped by the
+    // trailing-slot verb guard.
+    ...roleSpec.valueShape !== void 0 ? { valueShape: roleSpec.valueShape } : {}
   };
   const prefixLiteral = roleSpec.valuePrefixLiteral?.[profile.code];
   const pushPrefixed = () => {
@@ -59762,6 +60193,7 @@ var init_pick = __esm({
     pickPatternsEn = [pickVariantEnglish];
   }
 });
+var VIEW_TRANSITION_TAIL;
 var swapSimpleEnglish;
 var swapElementEnglish;
 var swapStrategyOfEnglish;
@@ -59769,6 +60201,21 @@ var swapStrategyEnglish;
 var swapPatternsEn;
 var init_swap = __esm({
   "src/patterns/languages/en/swap.ts"() {
+    VIEW_TRANSITION_TAIL = {
+      type: "group",
+      optional: true,
+      tokens: [
+        { type: "literal", value: "using" },
+        { type: "literal", value: "view" },
+        {
+          type: "role",
+          role: "manner",
+          optional: true,
+          expectedTypes: ["literal", "expression"],
+          valueShape: "keyword"
+        }
+      ]
+    };
     swapSimpleEnglish = {
       id: "swap-en-handcrafted",
       language: "en",
@@ -59776,11 +60223,12 @@ var init_swap = __esm({
       priority: 110,
       // Higher than generated patterns
       template: {
-        format: "swap {method} {destination}",
+        format: "swap {method} {destination} [using view {manner}]",
         tokens: [
           { type: "literal", value: "swap" },
           { type: "role", role: "method" },
-          { type: "role", role: "destination" }
+          { type: "role", role: "destination" },
+          VIEW_TRANSITION_TAIL
         ]
       },
       extraction: {
@@ -59794,12 +60242,13 @@ var init_swap = __esm({
       command: "swap",
       priority: 120,
       template: {
-        format: "swap {destination} with {patient}",
+        format: "swap {destination} with {patient} [using view {manner}]",
         tokens: [
           { type: "literal", value: "swap" },
           { type: "role", role: "destination" },
           { type: "literal", value: "with" },
-          { type: "role", role: "patient" }
+          { type: "role", role: "patient" },
+          VIEW_TRANSITION_TAIL
         ]
       },
       extraction: {}
@@ -59810,14 +60259,15 @@ var init_swap = __esm({
       command: "swap",
       priority: 140,
       template: {
-        format: "swap {method} of {destination} with {patient}",
+        format: "swap {method} of {destination} with {patient} [using view {manner}]",
         tokens: [
           { type: "literal", value: "swap" },
           { type: "role", role: "method" },
           { type: "literal", value: "of" },
           { type: "role", role: "destination" },
           { type: "literal", value: "with" },
-          { type: "role", role: "patient" }
+          { type: "role", role: "patient" },
+          VIEW_TRANSITION_TAIL
         ]
       },
       extraction: {}
@@ -59828,13 +60278,14 @@ var init_swap = __esm({
       command: "swap",
       priority: 130,
       template: {
-        format: "swap {method} {destination} with {patient}",
+        format: "swap {method} {destination} with {patient} [using view {manner}]",
         tokens: [
           { type: "literal", value: "swap" },
           { type: "role", role: "method" },
           { type: "role", role: "destination" },
           { type: "literal", value: "with" },
-          { type: "role", role: "patient" }
+          { type: "role", role: "patient" },
+          VIEW_TRANSITION_TAIL
         ]
       },
       extraction: {}
@@ -63325,6 +63776,7 @@ function isTypeCompatible(actualType, expectedTypes) {
   }
   return false;
 }
+init_marker_resolution();
 init_command_schemas();
 init_english();
 function getPossessiveReference(profile, keyword) {
@@ -63877,7 +64329,8 @@ var DefaultConfidenceModel = class {
     const hasDefault = (role) => {
       return pattern.extraction?.[role]?.default !== void 0;
     };
-    const schemaRoles = commandSchemas[pattern.command]?.roles;
+    const wrappedAction = pattern.command === "on" ? pattern.extraction?.action?.value : void 0;
+    const schemaRoles = commandSchemas[wrappedAction ?? pattern.command]?.roles;
     const isShapeAnchored = (role) => schemaRoles?.find((r) => r.role === role)?.valueShape !== void 0;
     for (const token of pattern.template.tokens) {
       if (token.type === "role") {
@@ -64270,7 +64723,7 @@ var _PatternMatcher2 = class _PatternMatcher3 {
         return patternToken.optional || false;
       }
     }
-    if (patternToken.optional && nextPatternToken === void 0 && patternToken.role !== "event" && patternToken.role !== "action" && token.kind === "keyword") {
+    if (patternToken.optional && nextPatternToken === void 0 && patternToken.role !== "event" && patternToken.role !== "action" && patternToken.valueShape !== "keyword" && token.kind === "keyword") {
       const verbNorm = (token.normalized ?? token.value).toLowerCase();
       if (verbNorm in commandSchemas) {
         return true;
@@ -64425,7 +64878,14 @@ var _PatternMatcher2 = class _PatternMatcher3 {
         }
       }
     }
-    captured.set(patternToken.role, value);
+    if (patternToken.valueShape === "keyword" && value.type === "expression") {
+      captured.set(
+        patternToken.role,
+        createLiteral(String(value.raw ?? ""))
+      );
+    } else {
+      captured.set(patternToken.role, value);
+    }
     tokens.advance();
     if (patternToken.role === "event") {
       const filterTok = tokens.peek();
@@ -65014,17 +65474,7 @@ var _PatternMatcher2 = class _PatternMatcher3 {
    * so this never blocks a genuine `my value` / `its style` possessive.
    */
   isRoleMarkerConcept(normalized2) {
-    const markerConcepts = /* @__PURE__ */ new Set([
-      "destination",
-      "source",
-      "patient",
-      "object",
-      "event",
-      "eventmarker",
-      "manner",
-      "instrument"
-    ]);
-    return markerConcepts.has(normalized2.toLowerCase());
+    return ROLE_MARKER_CONCEPTS.has(normalized2.toLowerCase());
   }
   /**
    * Does `token` look like an EVENT name for the `event` role? Events are bare
@@ -65410,7 +65860,7 @@ var _PatternMatcher2 = class _PatternMatcher3 {
    */
   matchGroupToken(tokens, patternToken, captured, nextPatternToken) {
     const mark = tokens.mark();
-    const capturedBefore = new Set(captured.keys());
+    const capturedBefore = new Map(captured);
     const success = this.matchTokenSequence(
       tokens,
       patternToken.tokens,
@@ -65424,6 +65874,11 @@ var _PatternMatcher2 = class _PatternMatcher3 {
           captured.delete(role);
         }
       }
+      for (const [role, value] of capturedBefore) {
+        if (captured.get(role) !== value) {
+          captured.set(role, value);
+        }
+      }
       return patternToken.optional || false;
     }
     return true;
@@ -65525,7 +65980,7 @@ var _PatternMatcher2 = class _PatternMatcher3 {
       } else if (rule.value !== void 0) {
         captured.set(role, { type: "literal", value: rule.value });
       } else if (rule.default) {
-        captured.set(role, rule.default);
+        captured.set(role, { ...rule.default, implicit: true });
       }
     }
   }
@@ -65716,6 +66171,7 @@ function registerTokenizer2(tokenizer) {
 }
 init_registry();
 init_command_schemas();
+init_marker_resolution();
 init_registry();
 var OPENER_ACTIONS = ["if", "unless", "repeat", "for", "while"];
 var PASCAL_CASE_NAME = /^[A-Z][A-Za-z0-9_]*$/;
@@ -66373,14 +66829,20 @@ var SemanticRendererImpl = class {
     return parts.join(" ");
   }
   /**
-   * Join a statement list the way a block body reads: ` then ` between siblings,
-   * but a single space immediately after a loop/tell block header (whose body
-   * follows directly). Shared by renderConditional's branches; renderCompound
-   * keeps its own copy because it also handles the multi-handler and bind-feature
-   * cases.
+   * Join a statement list the way a block body reads: the target language's `then`
+   * between siblings, but a single space immediately after a loop/tell block header
+   * (whose body follows directly). Used by renderConditional's branches;
+   * renderCompound keeps its own copy because it also handles the multi-handler
+   * and bind-feature cases.
+   *
+   * The chain word is localized (`this.keyword(language, 'then')`) for the same
+   * reason renderCompound localizes it: a hardcoded English `then` leaks into every
+   * non-en block body (`\u3082\u3057 \u2026 \u524a\u9664 then \u8ffd\u52a0`), which no target-language tokenizer
+   * recognizes as a connector.
    */
   joinStatements(statements, language) {
     const rendered = statements.map((s) => this.render(s, language));
+    const thenKw = this.keyword(language, "then");
     let out = rendered[0] ?? "";
     for (let i = 1; i < rendered.length; i++) {
       const prev = statements[i - 1];
@@ -66388,7 +66850,7 @@ var SemanticRendererImpl = class {
       if (prev.kind === "command" && BLOCK_NEEDS_TRAILING_END.has(prev.action)) {
         out += ` ${this.keyword(language, "end")}`;
       }
-      out += (afterBlockHeader ? " " : " then ") + rendered[i];
+      out += (afterBlockHeader ? " " : ` ${thenKw} `) + rendered[i];
     }
     return out;
   }
@@ -66561,6 +67023,7 @@ var SemanticRendererImpl = class {
             if (!roleToken) continue;
             const roleValue = node.roles.get(roleName);
             if (roleValue?.type !== "reference" || roleValue.value !== "me") continue;
+            if (!roleValue.implicit) continue;
             if (roleName === "destination") {
               const patient = node.roles.get("patient");
               if (patient?.type === "literal" && patient.dataType === "string") continue;
@@ -66998,7 +67461,7 @@ function fillSchemaDefaults(node) {
       const roles = node.roles;
       for (const spec of schema.roles) {
         if (spec.default !== void 0 && !roles.has(spec.role)) {
-          roles.set(spec.role, { ...spec.default });
+          roles.set(spec.role, { ...spec.default, implicit: true });
         }
       }
     }
@@ -67584,7 +68047,7 @@ var _SemanticParserImpl = class _SemanticParserImpl2 {
     }
     let eventModifiers = patternMatcher.extractEventModifiers(tokens);
     const sourceValue = match.captured.get("source");
-    if (sourceValue && match.pattern.id.includes("source") && !(sourceValue.type === "reference" && sourceValue.value === "me")) {
+    if (sourceValue && match.pattern.id.endsWith("source") && !(sourceValue.type === "reference" && sourceValue.value === "me")) {
       eventModifiers = { ...eventModifiers ?? {}, from: sourceValue };
     }
     const additionalEvents = this.extractOrConjunctionEvents(tokens, language);
@@ -67734,13 +68197,18 @@ var _SemanticParserImpl = class _SemanticParserImpl2 {
               if (!spec) return true;
               return spec.expectedTypes.length > 0 && !spec.expectedTypes.includes(valType(val));
             };
+            const isMarkerConceptJunk = (role, val) => role === "patient" && !!schema && !schema.roles.some((r) => r.role === "patient") && valType(val) === "literal" && ROLE_MARKER_CONCEPTS.has(
+              String(val.value ?? "").toLowerCase()
+            );
             const preservesFused = !!first && first.kind === "command" && Object.entries(roles).every(([role, val]) => {
-              if (isIgnorableFusedRole(role, val)) return true;
+              if (isIgnorableFusedRole(role, val) || isMarkerConceptJunk(role, val)) return true;
               const rv = first.roles.get(mapRole(role));
               if (rv !== void 0 && valType(rv) === valType(val)) return true;
               if (role === "patient" && actionName === "pick" && valType(val) === "literal") {
                 const mv = first.roles.get("method");
-                return mv !== void 0 && valType(mv) === "literal" && String(mv.value) === String(val.value);
+                const mvType = valType(mv);
+                const mvSurface = mvType === "literal" ? String(mv.value) : mvType === "expression" ? String(mv.raw) : void 0;
+                return mvSurface !== void 0 && mvSurface === String(val.value);
               }
               return false;
             });
@@ -67750,7 +68218,12 @@ var _SemanticParserImpl = class _SemanticParserImpl2 {
             // the swap can never swallow a body command. The body-swallowing
             // generated repeat matches none of these ids.
             /^repeat-.*-(times|for-in|while-head|until-head)$/.test(reparsePid);
-            if (reparsed.length === 1 && first && first.kind === "command" && first.action === actionName && preservesFused && headOnlyOk && first.roles.size > Object.keys(roles).length) {
+            if (reparsed.length === 1 && first && first.kind === "command" && first.action === actionName && preservesFused && headOnlyOk && // Strictly-more: the re-parse must recover something the fused
+            // capture lacked. Junk marker captures are excluded from the
+            // count \u2014 a fused shape whose ONLY role is a swallowed marker
+            // (scroll: `destination:literal="destination"`) would otherwise
+            // tie 1 > 1 and veto its own repair.
+            first.roles.size > Object.entries(roles).filter(([r, v2]) => !isMarkerConceptJunk(r, v2)).length) {
               commandNode = first;
               while (tokens.position() < clauseEnd) tokens.advance();
             } else {
@@ -74371,7 +74844,7 @@ function getGetPatternsBn() {
         tokens: [
           { type: "role", role: "source" },
           { type: "literal", value: "\u09A5\u09C7\u0995\u09C7" },
-          { type: "literal", value: "\u09AA\u09BE\u09A8", alternatives: ["\u09A8\u09BF\u09A8"] }
+          { type: "literal", value: "\u09AA\u09BE\u09A8" }
         ]
       },
       extraction: {
@@ -74387,7 +74860,7 @@ function getGetPatternsBn() {
       template: {
         format: "\u09AA\u09BE\u09A8 {source}",
         tokens: [
-          { type: "literal", value: "\u09AA\u09BE\u09A8", alternatives: ["\u09A8\u09BF\u09A8"] },
+          { type: "literal", value: "\u09AA\u09BE\u09A8" },
           { type: "role", role: "source" }
         ]
       },
@@ -74471,7 +74944,7 @@ function getGetPatternsIt() {
       template: {
         format: "ottenere {patient} da {source}",
         tokens: [
-          { type: "literal", value: "ottenere", alternatives: ["ottieni", "get", "prendere"] },
+          { type: "literal", value: "ottenere", alternatives: ["ottieni", "get"] },
           { type: "role", role: "patient" },
           {
             type: "group",
@@ -74561,7 +75034,7 @@ function getGetPatternsRu() {
       template: {
         format: "\u043F\u043E\u043B\u0443\u0447\u0438\u0442\u044C {patient} \u0438\u0437 {source}",
         tokens: [
-          { type: "literal", value: "\u043F\u043E\u043B\u0443\u0447\u0438\u0442\u044C", alternatives: ["\u043F\u043E\u043B\u0443\u0447\u0438", "\u0432\u0437\u044F\u0442\u044C", "\u0432\u043E\u0437\u044C\u043C\u0438"] },
+          { type: "literal", value: "\u043F\u043E\u043B\u0443\u0447\u0438\u0442\u044C", alternatives: ["\u043F\u043E\u043B\u0443\u0447\u0438"] },
           { type: "role", role: "patient" },
           {
             type: "group",
@@ -74586,7 +75059,7 @@ function getGetPatternsRu() {
       template: {
         format: "\u043F\u043E\u043B\u0443\u0447\u0438\u0442\u044C {patient}",
         tokens: [
-          { type: "literal", value: "\u043F\u043E\u043B\u0443\u0447\u0438\u0442\u044C", alternatives: ["\u043F\u043E\u043B\u0443\u0447\u0438", "\u0432\u0437\u044F\u0442\u044C", "\u0432\u043E\u0437\u044C\u043C\u0438"] },
+          { type: "literal", value: "\u043F\u043E\u043B\u0443\u0447\u0438\u0442\u044C", alternatives: ["\u043F\u043E\u043B\u0443\u0447\u0438"] },
           { type: "role", role: "patient" }
         ]
       },
@@ -74627,7 +75100,7 @@ function getGetPatternsUk() {
       template: {
         format: "\u043E\u0442\u0440\u0438\u043C\u0430\u0442\u0438 {patient} \u0437 {source}",
         tokens: [
-          { type: "literal", value: "\u043E\u0442\u0440\u0438\u043C\u0430\u0442\u0438", alternatives: ["\u043E\u0442\u0440\u0438\u043C\u0430\u0439", "\u0432\u0437\u044F\u0442\u0438", "\u0432\u0456\u0437\u044C\u043C\u0438"] },
+          { type: "literal", value: "\u043E\u0442\u0440\u0438\u043C\u0430\u0442\u0438", alternatives: ["\u043E\u0442\u0440\u0438\u043C\u0430\u0439"] },
           { type: "role", role: "patient" },
           {
             type: "group",
@@ -74652,7 +75125,7 @@ function getGetPatternsUk() {
       template: {
         format: "\u043E\u0442\u0440\u0438\u043C\u0430\u0442\u0438 {patient}",
         tokens: [
-          { type: "literal", value: "\u043E\u0442\u0440\u0438\u043C\u0430\u0442\u0438", alternatives: ["\u043E\u0442\u0440\u0438\u043C\u0430\u0439", "\u0432\u0437\u044F\u0442\u0438", "\u0432\u0456\u0437\u044C\u043C\u0438"] },
+          { type: "literal", value: "\u043E\u0442\u0440\u0438\u043C\u0430\u0442\u0438", alternatives: ["\u043E\u0442\u0440\u0438\u043C\u0430\u0439"] },
           { type: "role", role: "patient" }
         ]
       },
@@ -74672,7 +75145,7 @@ function getGetPatternsVi() {
       template: {
         format: "l\u1EA5y gi\xE1 tr\u1ECB c\u1EE7a {target}",
         tokens: [
-          { type: "literal", value: "l\u1EA5y gi\xE1 tr\u1ECB", alternatives: ["nh\u1EADn", "l\u1EA5y"] },
+          { type: "literal", value: "l\u1EA5y gi\xE1 tr\u1ECB", alternatives: ["nh\u1EADn"] },
           { type: "group", optional: true, tokens: [{ type: "literal", value: "c\u1EE7a" }] },
           { type: "role", role: "patient" }
         ]
@@ -74683,13 +75156,17 @@ function getGetPatternsVi() {
     },
     {
       id: "get-vi-simple",
+      // Head was `l\u1ea5y` (alt `l\u1ea5y gi\u00e1 tr\u1ecb`) \u2014 but bare `l\u1ea5y` is vi's TAKE verb,
+      // so this pattern claimed every `l\u1ea5y .active t\u1eeb \u2026`. vi's get verb is the
+      // three-word `l\u1ea5y gi\u00e1 tr\u1ecb` ("take the value of"), which is what the i18n
+      // transformer renders; the bare form has no valid `get` surface.
       language: "vi",
       command: "get",
       priority: 90,
       template: {
-        format: "l\u1EA5y {target}",
+        format: "l\u1EA5y gi\xE1 tr\u1ECB {target}",
         tokens: [
-          { type: "literal", value: "l\u1EA5y", alternatives: ["nh\u1EADn", "l\u1EA5y gi\xE1 tr\u1ECB"] },
+          { type: "literal", value: "l\u1EA5y gi\xE1 tr\u1ECB", alternatives: ["nh\u1EADn"] },
           { type: "role", role: "patient" }
         ]
       },
@@ -76428,6 +76905,12 @@ function getSendPatternsForLanguage(language) {
       return [];
   }
 }
+var PICK_UNIT_WORDS = /* @__PURE__ */ new Set(["character", "characters", "item", "items"]);
+var retypePickUnitWord = (raw) => {
+  if (PICK_UNIT_WORDS.has(raw)) return { type: "expression", raw };
+  const n = Number(raw);
+  return createLiteral(raw !== "" && !Number.isNaN(n) ? n : raw);
+};
 function makePickVariantPattern(language, spec) {
   const tokens = [{ type: "literal", value: "pick" }];
   if (spec.objectMarkers?.length) {
@@ -76467,7 +76950,7 @@ function makePickVariantPattern(language, spec) {
       tokens
     },
     extraction: {
-      method: { position: 1 },
+      method: { position: 1, transform: retypePickUnitWord },
       patient: { position: 2 },
       source: {
         marker: spec.srcMarker,
@@ -76518,7 +77001,7 @@ function makePickVerbFinalPattern(language, spec) {
     },
     extraction: {
       source: { position: 0 },
-      method: { position: 2 },
+      method: { position: 2, transform: retypePickUnitWord },
       patient: { position: 3 }
     }
   };
@@ -79005,7 +79488,7 @@ function createRuntimeInstance(options) {
   return new Runtime(options);
 }
 function getVersion() {
-  return "2.0.0";
+  return VERSION$1;
 }
 function toCompileError(error) {
   return {
@@ -86429,4 +86912,4 @@ export {
   toCoreAST,
   validatePartialContent
 };
-//# sourceMappingURL=dist-VGR6QDPB.js.map
+//# sourceMappingURL=dist-6PFOOXNF.js.map