@hyperfixi/core 2.9.4 → 2.10.0

package/dist/commands/dom/close.d.ts

@@ -6,10 +6,6 @@ export interface CloseCommandInput {
 }
 export declare class CloseCommand implements DecoratedCommand {
     static readonly metadata: {
-        isBlocking: boolean;
-        hasBody: boolean;
-        version: string;
-    } & {
         readonly description: "Close a dialog, details element, or popover";
         readonly syntax: readonly ["close", "close <target>"];
         readonly examples: readonly ["close", "close #myDialog", "close #details", "close #popup"];
@@ -18,10 +14,6 @@ export declare class CloseCommand implements DecoratedCommand {
         readonly compatibility: "standard";
     };
     get metadata(): {
-        isBlocking: boolean;
-        hasBody: boolean;
-        version: string;
-    } & {
         readonly description: "Close a dialog, details element, or popover";
         readonly syntax: readonly ["close", "close <target>"];
         readonly examples: readonly ["close", "close #myDialog", "close #details", "close #popup"];

package/dist/commands/dom/empty.d.ts

@@ -6,10 +6,6 @@ export interface EmptyCommandInput {
 }
 export declare class EmptyCommand implements DecoratedCommand {
     static readonly metadata: {
-        isBlocking: boolean;
-        hasBody: boolean;
-        version: string;
-    } & {
         readonly description: "Remove all children from an element (sets innerHTML to empty)";
         readonly syntax: readonly ["empty", "empty <target>", "empty the <target>"];
         readonly examples: readonly ["empty me", "empty #list", "empty .results"];
@@ -18,10 +14,6 @@ export declare class EmptyCommand implements DecoratedCommand {
         readonly compatibility: "standard";
     };
     get metadata(): {
-        isBlocking: boolean;
-        hasBody: boolean;
-        version: string;
-    } & {
         readonly description: "Remove all children from an element (sets innerHTML to empty)";
         readonly syntax: readonly ["empty", "empty <target>", "empty the <target>"];
         readonly examples: readonly ["empty me", "empty #list", "empty .results"];

package/dist/commands/dom/hide.d.ts

@@ -4,10 +4,6 @@ import type { VisibilityInput } from '../helpers/visibility-target-parser';
 export type HideCommandInput = VisibilityInput;
 export declare class HideCommand extends VisibilityCommandBase {
     static readonly metadata: {
-        isBlocking: boolean;
-        hasBody: boolean;
-        version: string;
-    } & {
         readonly description: "Hide elements by setting display to none";
         readonly syntax: "hide [<target>]";
         readonly examples: readonly ["hide me", "hide #modal", "hide .warnings", "hide <button/>"];
@@ -16,10 +12,6 @@ export declare class HideCommand extends VisibilityCommandBase {
         readonly compatibility: "standard";
     };
     get metadata(): {
-        isBlocking: boolean;
-        hasBody: boolean;
-        version: string;
-    } & {
         readonly description: "Hide elements by setting display to none";
         readonly syntax: "hide [<target>]";
         readonly examples: readonly ["hide me", "hide #modal", "hide .warnings", "hide <button/>"];

package/dist/commands/dom/make.d.ts

@@ -9,10 +9,6 @@ export interface MakeCommandInput {
 }
 export declare class MakeCommand implements DecoratedCommand {
     static readonly metadata: {
-        isBlocking: boolean;
-        hasBody: boolean;
-        version: string;
-    } & {
         readonly description: "Create DOM elements or class instances";
         readonly syntax: readonly ["make a <tag#id.class1.class2/>", "make a <ClassName> from <args> called <identifier>"];
         readonly examples: readonly ["make an <a.navlink/> called linkElement", "make a URL from \"/path/\", \"https://origin.example.com\""];
@@ -21,10 +17,6 @@ export declare class MakeCommand implements DecoratedCommand {
         readonly compatibility: "standard";
     };
     get metadata(): {
-        isBlocking: boolean;
-        hasBody: boolean;
-        version: string;
-    } & {
         readonly description: "Create DOM elements or class instances";
         readonly syntax: readonly ["make a <tag#id.class1.class2/>", "make a <ClassName> from <args> called <identifier>"];
         readonly examples: readonly ["make an <a.navlink/> called linkElement", "make a URL from \"/path/\", \"https://origin.example.com\""];

package/dist/commands/dom/open.d.ts

@@ -8,10 +8,6 @@ export interface OpenCommandInput {
 }
 export declare class OpenCommand implements DecoratedCommand {
     static readonly metadata: {
-        isBlocking: boolean;
-        hasBody: boolean;
-        version: string;
-    } & {
         readonly description: "Open a dialog, details element, or popover";
         readonly syntax: readonly ["open [<target>]", "open <dialog> as modal", "open <dialog> as non-modal"];
         readonly examples: readonly ["open", "open #myDialog", "open #details", "open #popup as non-modal"];
@@ -20,10 +16,6 @@ export declare class OpenCommand implements DecoratedCommand {
         readonly compatibility: "standard";
     };
     get metadata(): {
-        isBlocking: boolean;
-        hasBody: boolean;
-        version: string;
-    } & {
         readonly description: "Open a dialog, details element, or popover";
         readonly syntax: readonly ["open [<target>]", "open <dialog> as modal", "open <dialog> as non-modal"];
         readonly examples: readonly ["open", "open #myDialog", "open #details", "open #popup as non-modal"];

package/dist/commands/dom/process-partials.d.ts

@@ -26,10 +26,6 @@ export declare function extractPartials(html: string): ParsedPartial[];
 export declare function processPartials(html: string, morphOptions?: MorphOptions): ProcessPartialsResult;
 export declare class ProcessPartialsCommand implements DecoratedCommand {
     static readonly metadata: {
-        isBlocking: boolean;
-        hasBody: boolean;
-        version: string;
-    } & {
         readonly description: "Process <hx-partial> elements for multi-target swaps";
         readonly syntax: readonly ["process partials in <content>", "process partials in <content> using view transition"];
         readonly examples: readonly ["process partials in it", "process partials in fetchedHtml", "process partials in it using view transition"];
@@ -38,10 +34,6 @@ export declare class ProcessPartialsCommand implements DecoratedCommand {
         readonly compatibility: "lokascript-extension";
     };
     get metadata(): {
-        isBlocking: boolean;
-        hasBody: boolean;
-        version: string;
-    } & {
         readonly description: "Process <hx-partial> elements for multi-target swaps";
         readonly syntax: readonly ["process partials in <content>", "process partials in <content> using view transition"];
         readonly examples: readonly ["process partials in it", "process partials in fetchedHtml", "process partials in it using view transition"];

package/dist/commands/dom/put.d.ts

@@ -13,10 +13,6 @@ export interface PutCommandInput {
 }
 export declare class PutCommand implements DecoratedCommand {
     static readonly metadata: {
-        isBlocking: boolean;
-        hasBody: boolean;
-        version: string;
-    } & {
         readonly description: "Insert content into elements or properties";
         readonly syntax: readonly ["put <value> into <target>", "put <value> before <target>", "put <value> after <target>"];
         readonly examples: readonly ["put \"Hello World\" into me", "put <div>Content</div> before #target", "put value into #elem's innerHTML"];
@@ -25,10 +21,6 @@ export declare class PutCommand implements DecoratedCommand {
         readonly compatibility: "standard";
     };
     get metadata(): {
-        isBlocking: boolean;
-        hasBody: boolean;
-        version: string;
-    } & {
         readonly description: "Insert content into elements or properties";
         readonly syntax: readonly ["put <value> into <target>", "put <value> before <target>", "put <value> after <target>"];
         readonly examples: readonly ["put \"Hello World\" into me", "put <div>Content</div> before #target", "put value into #elem's innerHTML"];

package/dist/commands/dom/remove.d.ts

@@ -20,10 +20,6 @@ export type RemoveCommandInput = {
 };
 export declare class RemoveCommand extends DOMModificationBase {
     static readonly metadata: {
-        isBlocking: boolean;
-        hasBody: boolean;
-        version: string;
-    } & {
         readonly description: "Remove CSS classes, attributes, styles, or elements from the DOM";
         readonly syntax: "remove <classes|@attr|*prop|element> [from <target>]";
         readonly examples: readonly ["remove .active from me", "remove \"active selected\" from <button/>", "remove .highlighted from #modal", "remove me", "remove closest .item"];
@@ -32,10 +28,6 @@ export declare class RemoveCommand extends DOMModificationBase {
         readonly compatibility: "standard";
     };
     get metadata(): {
-        isBlocking: boolean;
-        hasBody: boolean;
-        version: string;
-    } & {
         readonly description: "Remove CSS classes, attributes, styles, or elements from the DOM";
         readonly syntax: "remove <classes|@attr|*prop|element> [from <target>]";
         readonly examples: readonly ["remove .active from me", "remove \"active selected\" from <button/>", "remove .highlighted from #modal", "remove me", "remove closest .item"];

package/dist/commands/dom/reset.d.ts

@@ -6,10 +6,6 @@ export interface ResetCommandInput {
 }
 export declare class ResetCommand implements DecoratedCommand {
     static readonly metadata: {
-        isBlocking: boolean;
-        hasBody: boolean;
-        version: string;
-    } & {
         readonly description: "Reset a <form> element to its default values (HTMLFormElement.reset())";
         readonly syntax: readonly ["reset", "reset <target>"];
         readonly examples: readonly ["reset", "reset #myForm", "reset <form/>"];
@@ -18,10 +14,6 @@ export declare class ResetCommand implements DecoratedCommand {
         readonly compatibility: "standard";
     };
     get metadata(): {
-        isBlocking: boolean;
-        hasBody: boolean;
-        version: string;
-    } & {
         readonly description: "Reset a <form> element to its default values (HTMLFormElement.reset())";
         readonly syntax: readonly ["reset", "reset <target>"];
         readonly examples: readonly ["reset", "reset #myForm", "reset <form/>"];

package/dist/commands/dom/select.d.ts

@@ -6,10 +6,6 @@ export interface SelectCommandInput {
 }
 export declare class SelectCommand implements DecoratedCommand {
     static readonly metadata: {
-        isBlocking: boolean;
-        hasBody: boolean;
-        version: string;
-    } & {
         readonly description: "Select the contents of a text field, or select the contents of a DOM element";
         readonly syntax: readonly ["select", "select <target>"];
         readonly examples: readonly ["select #search", "select <textarea/>", "select me"];
@@ -18,10 +14,6 @@ export declare class SelectCommand implements DecoratedCommand {
         readonly compatibility: "standard";
     };
     get metadata(): {
-        isBlocking: boolean;
-        hasBody: boolean;
-        version: string;
-    } & {
         readonly description: "Select the contents of a text field, or select the contents of a DOM element";
         readonly syntax: readonly ["select", "select <target>"];
         readonly examples: readonly ["select #search", "select <textarea/>", "select me"];

package/dist/commands/dom/show.d.ts

@@ -5,10 +5,6 @@ export interface ShowCommandInput extends VisibilityCommandInput {
 }
 export declare class ShowCommand extends VisibilityCommandBase {
     static readonly metadata: {
-        isBlocking: boolean;
-        hasBody: boolean;
-        version: string;
-    } & {
         readonly description: "Show elements by restoring display property";
         readonly syntax: "show [<target>]";
         readonly examples: readonly ["show me", "show #modal", "show .hidden", "show <button/>"];
@@ -17,10 +13,6 @@ export declare class ShowCommand extends VisibilityCommandBase {
         readonly compatibility: "standard";
     };
     get metadata(): {
-        isBlocking: boolean;
-        hasBody: boolean;
-        version: string;
-    } & {
         readonly description: "Show elements by restoring display property";
         readonly syntax: "show [<target>]";
         readonly examples: readonly ["show me", "show #modal", "show .hidden", "show <button/>"];

package/dist/commands/dom/swap.d.ts

@@ -17,10 +17,6 @@ export interface SwapCommandInput {
 }
 export declare class SwapCommand implements DecoratedCommand {
     static readonly metadata: {
-        isBlocking: boolean;
-        hasBody: boolean;
-        version: string;
-    } & {
         readonly description: "Swap content into target elements with intelligent morphing support";
         readonly syntax: readonly ["swap <target> with <content>", "swap [strategy] of <target> with <content>", "swap into <target> with <content>", "swap over <target> with <content>", "swap delete <target>", "swap <target> with <content> using view transition"];
         readonly examples: readonly ["swap #target with it", "swap innerHTML of #target with it", "swap over #modal with fetchedContent", "swap delete #notification"];
@@ -29,10 +25,6 @@ export declare class SwapCommand implements DecoratedCommand {
         readonly compatibility: "standard";
     };
     get metadata(): {
-        isBlocking: boolean;
-        hasBody: boolean;
-        version: string;
-    } & {
         readonly description: "Swap content into target elements with intelligent morphing support";
         readonly syntax: readonly ["swap <target> with <content>", "swap [strategy] of <target> with <content>", "swap into <target> with <content>", "swap over <target> with <content>", "swap delete <target>", "swap <target> with <content> using view transition"];
         readonly examples: readonly ["swap #target with it", "swap innerHTML of #target with it", "swap over #modal with fetchedContent", "swap delete #notification"];
@@ -49,24 +41,16 @@ export declare class SwapCommand implements DecoratedCommand {
 }
 export declare class MorphCommand implements DecoratedCommand {
     static readonly metadata: {
-        isBlocking: boolean;
-        hasBody: boolean;
-        version: string;
-    } & {
         readonly description: "Morph content into target elements (intelligent diffing, preserves state)";
-        readonly syntax: readonly ["morph <target> with <content>", "morph over <target> with <content>"];
+        readonly syntax: readonly ["morph <target> with <content>", "morph over <target> with <content>", "morph <target> with <content> using view transition"];
         readonly examples: readonly ["morph #target with it", "morph over #modal with fetchedContent"];
         readonly sideEffects: readonly ["dom-mutation"];
         readonly category: "dom";
         readonly compatibility: "standard";
     };
     get metadata(): {
-        isBlocking: boolean;
-        hasBody: boolean;
-        version: string;
-    } & {
         readonly description: "Morph content into target elements (intelligent diffing, preserves state)";
-        readonly syntax: readonly ["morph <target> with <content>", "morph over <target> with <content>"];
+        readonly syntax: readonly ["morph <target> with <content>", "morph over <target> with <content>", "morph <target> with <content> using view transition"];
         readonly examples: readonly ["morph #target with it", "morph over #modal with fetchedContent"];
         readonly sideEffects: readonly ["dom-mutation"];
         readonly category: "dom";

package/dist/commands/dom/toggle.d.ts

@@ -45,10 +45,6 @@ export type ToggleCommandInput = {
 };
 export declare class ToggleCommand implements DecoratedCommand {
     static readonly metadata: {
-        isBlocking: boolean;
-        hasBody: boolean;
-        version: string;
-    } & {
         readonly description: "Toggle classes, attributes, or interactive elements";
         readonly syntax: readonly ["toggle <class> [on <target>]", "toggle @attr", "toggle <element> [as modal]", "toggle <expr> for <duration>"];
         readonly examples: readonly ["toggle .active on me", "toggle @disabled", "toggle #myDialog as modal", "toggle .loading for 2s"];
@@ -57,10 +53,6 @@ export declare class ToggleCommand implements DecoratedCommand {
         readonly compatibility: "standard";
     };
     get metadata(): {
-        isBlocking: boolean;
-        hasBody: boolean;
-        version: string;
-    } & {
         readonly description: "Toggle classes, attributes, or interactive elements";
         readonly syntax: readonly ["toggle <class> [on <target>]", "toggle @attr", "toggle <element> [as modal]", "toggle <expr> for <duration>"];
         readonly examples: readonly ["toggle .active on me", "toggle @disabled", "toggle #myDialog as modal", "toggle .loading for 2s"];

package/dist/commands/events/trigger.d.ts

@@ -16,10 +16,6 @@ export type TriggerCommandInput = Omit<EventDispatchInput, 'mode'>;
 export type SendCommandInput = Omit<EventDispatchInput, 'mode'>;
 export declare class EventDispatchCommand implements DecoratedCommand {
     static readonly metadata: {
-        isBlocking: boolean;
-        hasBody: boolean;
-        version: string;
-    } & {
         readonly description: "Dispatch events on elements";
         readonly syntax: readonly ["trigger <event> on <target>", "trigger <event>(<detail>) on <target>", "send <event> to <target>", "send <event>(<detail>) to <target>"];
         readonly examples: readonly ["trigger click on #button", "trigger customEvent on me", "send dataEvent to #target", "send myEvent(count: 42) to me"];
@@ -29,10 +25,6 @@ export declare class EventDispatchCommand implements DecoratedCommand {
         readonly compatibility: "standard";
     };
     get metadata(): {
-        isBlocking: boolean;
-        hasBody: boolean;
-        version: string;
-    } & {
         readonly description: "Dispatch events on elements";
         readonly syntax: readonly ["trigger <event> on <target>", "trigger <event>(<detail>) on <target>", "send <event> to <target>", "send <event>(<detail>) to <target>"];
         readonly examples: readonly ["trigger click on #button", "trigger customEvent on me", "send dataEvent to #target", "send myEvent(count: 42) to me"];

package/dist/commands/execution/blur.d.ts

@@ -6,10 +6,6 @@ export interface BlurCommandInput {
 }
 export declare class BlurCommand implements DecoratedCommand {
     static readonly metadata: {
-        isBlocking: boolean;
-        hasBody: boolean;
-        version: string;
-    } & {
         readonly description: "Remove focus from an element (calls HTMLElement.blur())";
         readonly syntax: readonly ["blur", "blur <target>", "blur on <target>"];
         readonly examples: readonly ["blur", "blur #search", "blur on <input/>"];
@@ -18,10 +14,6 @@ export declare class BlurCommand implements DecoratedCommand {
         readonly compatibility: "standard";
     };
     get metadata(): {
-        isBlocking: boolean;
-        hasBody: boolean;
-        version: string;
-    } & {
         readonly description: "Remove focus from an element (calls HTMLElement.blur())";
         readonly syntax: readonly ["blur", "blur <target>", "blur on <target>"];
         readonly examples: readonly ["blur", "blur #search", "blur on <input/>"];

package/dist/commands/execution/call.d.ts

@@ -11,10 +11,6 @@ export interface CallCommandOutput {
 }
 export declare class CallCommand implements DecoratedCommand {
     static readonly metadata: {
-        isBlocking: boolean;
-        hasBody: boolean;
-        version: string;
-    } & {
         readonly description: "Evaluate an expression and store the result in the it variable";
         readonly syntax: readonly ["call <expression>"];
         readonly examples: readonly ["call myFunction()", "call fetch(\"/api/data\")", "call element.focus()"];
@@ -23,10 +19,6 @@ export declare class CallCommand implements DecoratedCommand {
         readonly compatibility: "standard";
     };
     get metadata(): {
-        isBlocking: boolean;
-        hasBody: boolean;
-        version: string;
-    } & {
         readonly description: "Evaluate an expression and store the result in the it variable";
         readonly syntax: readonly ["call <expression>"];
         readonly examples: readonly ["call myFunction()", "call fetch(\"/api/data\")", "call element.focus()"];

package/dist/commands/execution/focus.d.ts

@@ -6,10 +6,6 @@ export interface FocusCommandInput {
 }
 export declare class FocusCommand implements DecoratedCommand {
     static readonly metadata: {
-        isBlocking: boolean;
-        hasBody: boolean;
-        version: string;
-    } & {
         readonly description: "Focus an element (calls HTMLElement.focus())";
         readonly syntax: readonly ["focus", "focus <target>", "focus on <target>"];
         readonly examples: readonly ["focus", "focus #search", "focus on <input/>"];
@@ -18,10 +14,6 @@ export declare class FocusCommand implements DecoratedCommand {
         readonly compatibility: "standard";
     };
     get metadata(): {
-        isBlocking: boolean;
-        hasBody: boolean;
-        version: string;
-    } & {
         readonly description: "Focus an element (calls HTMLElement.focus())";
         readonly syntax: readonly ["focus", "focus <target>", "focus on <target>"];
         readonly examples: readonly ["focus", "focus #search", "focus on <input/>"];

package/dist/commands/execution/pseudo-command.d.ts

@@ -15,10 +15,6 @@ export interface PseudoCommandOutput {
 export declare class PseudoCommand {
     readonly name = "pseudo-command";
     static readonly metadata: {
-        isBlocking: boolean;
-        hasBody: boolean;
-        version: string;
-    } & {
         readonly description: "Treat a method on an object as a top-level command";
         readonly syntax: readonly ["<method>(<args>) [(to|on|with|into|from|at)] <expression>"];
         readonly examples: readonly ["getElementById(\"d1\") from the document", "reload() the location of the window", "setAttribute(\"foo\", \"bar\") on me", "foo() on me"];
@@ -27,10 +23,6 @@ export declare class PseudoCommand {
         readonly sideEffects: readonly ["method-execution"];
     };
     get metadata(): {
-        isBlocking: boolean;
-        hasBody: boolean;
-        version: string;
-    } & {
         readonly description: "Treat a method on an object as a top-level command";
         readonly syntax: readonly ["<method>(<args>) [(to|on|with|into|from|at)] <expression>"];
         readonly examples: readonly ["getElementById(\"d1\") from the document", "reload() the location of the window", "setAttribute(\"foo\", \"bar\") on me", "foo() on me"];

package/dist/commands/index.js

@@ -71,7 +71,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();
@@ -7750,6 +7750,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('{')) {
@@ -7871,6 +7905,7 @@ function parseSwapCommand(ctx, identifierNode) {
             args.push(contentExpr);
         }
     }
+    consumeViewTransitionTail(ctx, args);
     return CommandNodeBuilder.fromIdentifier(identifierNode)
         .withArgs(...args)
         .endingAt(ctx.getPosition())
@@ -8384,6 +8419,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);
     }
@@ -8715,6 +8753,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()) {
@@ -8734,7 +8775,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()) {
@@ -11072,6 +11117,7 @@ class Parser {
             'js',
             'tell',
             'fetch',
+            'process',
         ];
         if (this.semanticAdapter && !skipSemanticParsing.includes(commandName.toLowerCase())) {
             const remainingInput = this.getRemainingInput();
@@ -14335,7 +14381,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')) {
@@ -14545,7 +14591,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')) {
@@ -14626,7 +14672,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',
@@ -15236,24 +15286,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;
@@ -15267,10 +15326,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;
                 }