@hyperfixi/core 2.9.4 → 2.11.0

package/dist/index.mjs

@@ -4461,6 +4461,40 @@ function parseTakeCommand(ctx, identifierNode) {
         .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('{')) {
@@ -4582,6 +4616,7 @@ function parseSwapCommand(ctx, identifierNode) {
             args.push(contentExpr);
         }
     }
+    consumeViewTransitionTail(ctx, args);
     return CommandNodeBuilder.fromIdentifier(identifierNode)
         .withArgs(...args)
         .endingAt(ctx.getPosition())
@@ -5095,6 +5130,9 @@ 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);
     }
@@ -5426,6 +5464,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()) {
@@ -5445,7 +5486,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()) {
@@ -7783,6 +7828,7 @@ class Parser {
             'js',
             'tell',
             'fetch',
+            'process',
         ];
         if (this.semanticAdapter && !skipSemanticParsing.includes(commandName.toLowerCase())) {
             const remainingInput = this.getRemainingInput();
@@ -8737,6 +8783,12 @@ function isHTMLElement$2(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' &&
@@ -10609,6 +10661,12 @@ 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);
     }
@@ -10628,7 +10686,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') {
@@ -10639,12 +10696,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] !== undefined) {
@@ -11939,7 +11993,7 @@ class CommandAdapterV2 {
         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) {
@@ -12015,10 +12069,8 @@ class CommandAdapterV2 {
         }
     }
     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: [] };
     }
 }
 class CommandRegistryV2 {
@@ -16873,7 +16925,7 @@ function command(config) {
     };
 }
 function commandMeta(metadata) {
-    return { isBlocking: false, hasBody: false, version: '1.0.0', ...metadata };
+    return { ...metadata };
 }
 function createFactory(CommandClass) {
     return () => new CommandClass();
@@ -17776,7 +17828,7 @@ function insertContent(target, content, position) {
         insertReplace(target, content);
         return;
     }
-    if (isHTMLElement$2(content)) {
+    if (isInsertableNode(content)) {
         insertElement(target, content, position);
     }
     else {
@@ -17787,7 +17839,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);
     }
@@ -17834,6 +17886,53 @@ 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();
@@ -18924,7 +19023,12 @@ let 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;
@@ -18956,6 +19060,11 @@ let PutCommand = (() => {
         parseValue(v) {
             if (isHTMLElement$2(v))
                 return v;
+            if (Array.isArray(v) && v.length > 0 && v.every(isHTMLElement$2)) {
+                return v;
+            }
+            if (isInsertableNode(v))
+                return v;
             return v == null ? '' : String(v);
         }
         looksLikeCss(s) {
@@ -20177,8 +20286,9 @@ const morphAdapter = {
 function getStartViewTransition() {
     if (typeof document === 'undefined')
         return undefined;
-    return document
+    const fn = document
         .startViewTransition;
+    return typeof fn === 'function' ? fn.bind(document) : undefined;
 }
 function isViewTransitionsSupported() {
     return typeof getStartViewTransition() === 'function';
@@ -20440,7 +20550,7 @@ let SwapCommand = (() => {
                     };
                 }
             }
-            let useViewTransition = false;
+            let useViewTransition = raw.modifiers?.viewTransition !== undefined;
             if (usingIndex !== -1) {
                 const afterUsing = argKeywords.slice(usingIndex + 1);
                 if (afterUsing.includes('view') && afterUsing.includes('transition')) {
@@ -20650,7 +20760,7 @@ let 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 !== undefined;
             if (usingIndex !== -1) {
                 const afterUsing = argKeywords.slice(usingIndex + 1);
                 if (afterUsing.includes('view') && afterUsing.includes('transition')) {
@@ -20731,7 +20841,11 @@ let 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',
@@ -21363,24 +21477,33 @@ let 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>');
+                if (inIndex !== -1) {
+                    throw new Error('process command expects "partials" keyword: process partials in <content>');
+                }
+                contentNode = args[0];
             }
-            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>');
+            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) : undefined;
             let html;
             if (typeof contentArg === 'string') {
                 html = contentArg;
@@ -21394,10 +21517,10 @@ let 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 !== undefined;
+            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;
                 }
@@ -27264,6 +27387,8 @@ class Runtime extends RuntimeBase {
     }
 }
 
+const VERSION$1 = '2.10.0';
+
 // src/types.ts
 function createLiteral$1(value, dataType) {
   return dataType ? { type: "literal", value, dataType } : { type: "literal", value };
@@ -31605,14 +31730,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) {
@@ -35886,7 +36023,7 @@ function getSchemasByCategory(category) {
 function getDefinedSchemas() {
   return Object.values(commandSchemas).filter((s) => s.roles.length > 0 || s.bareKeyword === true);
 }
-var toggleSchema, addSchema, removeSchema, putSchema, setSchema, bindSchema, liveSchema, eventsourceSchema, socketSchema, workerSchema, interceptSchema, showSchema, hideSchema, onSchema, triggerSchema, waitSchema, fetchSchema, incrementSchema, decrementSchema, appendSchema, prependSchema, logSchema, getCommandSchema, takeSchema, makeSchema, haltSchema, settleSchema, throwSchema, sendSchema, ifSchema, unlessSchema, elseSchema, repeatSchema, forSchema, whileSchema, continueSchema, URL_MARKER_ALL_LANGS, goSchema, transitionSchema, cloneSchema, focusSchema, blurSchema, emptySchema, openSchema, closeSchema, selectSchema, clearSchema, resetSchema, breakpointSchema, callSchema, returnSchema, jsSchema, asyncSchema, tellSchema, defaultSchema, initSchema, behaviorSchema, installSchema, measureSchema, swapSchema, morphSchema, beepSchema, breakSchema, copySchema, exitSchema, pickSchema, scrollSchema, PARTIALS_IN_MARKER_ALL_LANGS, pushSchema, replaceSchema, processSchema, renderSchema, commandSchemas;
+var toggleSchema, addSchema, removeSchema, putSchema, setSchema, bindSchema, liveSchema, eventsourceSchema, socketSchema, workerSchema, interceptSchema, showSchema, hideSchema, onSchema, triggerSchema, waitSchema, fetchSchema, incrementSchema, decrementSchema, appendSchema, prependSchema, logSchema, getCommandSchema, takeSchema, makeSchema, haltSchema, settleSchema, throwSchema, sendSchema, ifSchema, unlessSchema, elseSchema, repeatSchema, forSchema, whileSchema, continueSchema, URL_MARKER_ALL_LANGS, goSchema, transitionSchema, cloneSchema, focusSchema, blurSchema, emptySchema, openSchema, closeSchema, selectSchema, clearSchema, resetSchema, breakpointSchema, callSchema, returnSchema, jsSchema, asyncSchema, tellSchema, defaultSchema, initSchema, behaviorSchema, installSchema, measureSchema, USING_VIEW_MARKER_ALL_LANGS, VIEW_TRANSITION_MANNER_ROLE, swapSchema, morphSchema, beepSchema, breakSchema, copySchema, exitSchema, pickSchema, scrollSchema, PARTIALS_IN_MARKER_ALL_LANGS, pushSchema, replaceSchema, processSchema, renderSchema, commandSchemas;
 var init_command_schemas = __esm({
   "src/generators/command-schemas.ts"() {
     toggleSchema = {
@@ -35895,7 +36032,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: [
         {
@@ -35905,7 +36041,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",
@@ -36243,6 +36385,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",
@@ -36265,9 +36409,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",
@@ -36310,8 +36464,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
@@ -36324,7 +36484,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"]
           }
         },
         {
@@ -36986,8 +37150,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",
@@ -37010,6 +37174,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" }
         }
       ]
     };
@@ -38074,6 +38270,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.)",
@@ -38094,7 +38331,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",
@@ -38189,6 +38430,11 @@ var init_command_schemas = __esm({
             ar: "\u0628\u0640",
             tl: "nang"
           }
+        },
+        {
+          ...VIEW_TRANSITION_MANNER_ROLE,
+          svoPosition: 4,
+          sovPosition: 4
         }
       ]
     };
@@ -38199,7 +38445,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",
@@ -38220,6 +38474,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
         }
       ]
     };
@@ -38406,6 +38672,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",
@@ -38415,6 +38688,11 @@ var init_command_schemas = __esm({
           svoPosition: 1,
           sovPosition: 1,
           markerOverride: PARTIALS_IN_MARKER_ALL_LANGS
+        },
+        {
+          ...VIEW_TRANSITION_MANNER_ROLE,
+          svoPosition: 2,
+          sovPosition: 2
         }
       ]
     };
@@ -40009,7 +40287,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
@@ -40022,7 +40302,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" },
@@ -40088,9 +40374,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" },
@@ -43873,9 +44165,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" },
@@ -43896,7 +44196,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`
@@ -43906,7 +44208,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" },
@@ -44859,6 +45167,60 @@ var init_chinese = __esm({
   }
 });
 
+// src/parser/utils/marker-resolution.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 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"
+    ]);
+  }
+});
+
 // src/patterns/put.ts
 function getPutPatternsBn() {
   return [
@@ -59719,49 +60081,6 @@ var init_role_positioning = __esm({
   }
 });
 
-// src/parser/utils/marker-resolution.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"() {
-  }
-});
-
 // src/generators/event-handlers-sov.ts
 function resolveRoleMarker(roleSpec, profile) {
   let marker;
@@ -59795,6 +60114,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, config) {
   const tokens = [];
   tokens.push({ type: "role", role: "event", optional: false });
@@ -59889,6 +60246,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,
@@ -59898,13 +60264,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, config) {
+  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: (config.basePriority ?? 100) + 48,
+    template: {
+      format: `{patient} ${patientMarker?.primary || ""} {source} ${sourceMarker} {event} ${eventMarker.primary} ${keyword.primary}`,
+      tokens
+    },
+    extraction
   };
 }
 function generateSOVPatientFirstWithDestEventHandlerPattern(commandSchema, profile, keyword, eventMarker, config) {
@@ -60346,6 +60770,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,
@@ -60356,15 +60790,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, config) {
@@ -60807,6 +61233,14 @@ function generateEventHandlerPatterns(commandSchema, profile, config = defaultCo
           config
         )
       );
+      const sourceFronted = generateSOVPatientFirstSourceFrontedEventHandlerPattern(
+        commandSchema,
+        profile,
+        keyword,
+        eventMarker,
+        config
+      );
+      if (sourceFronted) patterns.push(sourceFronted);
       const destMarkerCheck = profile.roleMarkers.destination;
       if (destMarkerCheck && destMarkerCheck.primary !== eventMarker.primary) {
         patterns.push(
@@ -60966,7 +61400,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 = () => {
@@ -61275,9 +61713,24 @@ var init_pick = __esm({
 });
 
 // src/patterns/languages/en/swap.ts
-var swapSimpleEnglish, swapElementEnglish, swapStrategyOfEnglish, swapStrategyEnglish, swapPatternsEn;
+var VIEW_TRANSITION_TAIL, swapSimpleEnglish, swapElementEnglish, swapStrategyOfEnglish, swapStrategyEnglish, 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",
@@ -61285,11 +61738,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: {
@@ -61303,12 +61757,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: {}
@@ -61319,14 +61774,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: {}
@@ -61337,13 +61793,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: {}
@@ -64713,6 +65170,7 @@ function isTypeCompatible(actualType, expectedTypes) {
 }
 
 // src/parser/pattern-matcher.ts
+init_marker_resolution();
 init_command_schemas();
 
 // src/parser/utils/possessive-keywords.ts
@@ -65277,7 +65735,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") {
@@ -65681,7 +66140,7 @@ var _PatternMatcher = class _PatternMatcher {
         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;
@@ -65836,7 +66295,14 @@ var _PatternMatcher = class _PatternMatcher {
         }
       }
     }
-    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();
@@ -66425,17 +66891,7 @@ var _PatternMatcher = class _PatternMatcher {
    * 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
@@ -66821,7 +67277,7 @@ var _PatternMatcher = class _PatternMatcher {
    */
   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,
@@ -66835,6 +67291,11 @@ var _PatternMatcher = class _PatternMatcher {
           captured.delete(role);
         }
       }
+      for (const [role, value] of capturedBefore) {
+        if (captured.get(role) !== value) {
+          captured.set(role, value);
+        }
+      }
       return patternToken.optional || false;
     }
     return true;
@@ -66936,7 +67397,7 @@ var _PatternMatcher = class _PatternMatcher {
       } 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 });
       }
     }
   }
@@ -67224,6 +67685,7 @@ function registerTokenizer2(tokenizer) {
 // src/parser/semantic-parser.ts
 init_registry();
 init_command_schemas();
+init_marker_resolution();
 
 // src/parser/block-parser.ts
 init_registry();
@@ -67889,14 +68351,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];
@@ -67904,7 +68372,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;
   }
@@ -68077,6 +68545,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;
@@ -68518,7 +68987,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 });
         }
       }
     }
@@ -69123,7 +69592,7 @@ var _SemanticParserImpl = class _SemanticParserImpl {
     }
     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);
@@ -69273,13 +69742,18 @@ var _SemanticParserImpl = class _SemanticParserImpl {
               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;
             });
@@ -69289,7 +69763,12 @@ var _SemanticParserImpl = class _SemanticParserImpl {
             // 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, v]) => !isMarkerConceptJunk(r, v)).length) {
               commandNode = first;
               while (tokens.position() < clauseEnd) tokens.advance();
             } else {
@@ -76088,7 +76567,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: {
@@ -76104,7 +76583,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" }
         ]
       },
@@ -76188,7 +76667,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",
@@ -76278,7 +76757,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",
@@ -76303,7 +76782,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" }
         ]
       },
@@ -76344,7 +76823,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",
@@ -76369,7 +76848,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" }
         ]
       },
@@ -76389,7 +76868,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" }
         ]
@@ -76400,13 +76879,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" }
         ]
       },
@@ -78165,6 +78648,12 @@ function getSendPatternsForLanguage(language) {
 }
 
 // src/patterns/pick.ts
+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) {
@@ -78204,7 +78693,7 @@ function makePickVariantPattern(language, spec) {
       tokens
     },
     extraction: {
-      method: { position: 1 },
+      method: { position: 1, transform: retypePickUnitWord },
       patient: { position: 2 },
       source: {
         marker: spec.srcMarker,
@@ -78255,7 +78744,7 @@ function makePickVerbFinalPattern(language, spec) {
     },
     extraction: {
       source: { position: 0 },
-      method: { position: 2 },
+      method: { position: 2, transform: retypePickUnitWord },
       patient: { position: 3 }
     }
   };
@@ -80686,7 +81175,7 @@ function createRuntimeInstance(options) {
     return new Runtime(options);
 }
 function getVersion() {
-    return '2.0.0';
+    return VERSION$1;
 }
 function toCompileError(error) {
     return {