Macros 2.0 [Fix] - Fix macro evaluation to allow nested scoped macros in arguments (#4977) * Fix scoped macro evaluation to allow nested scoped macros in arguments - Refactor `#evaluateArgumentNode` to re-parse argument content for scoped macro pairs - Create shared `#evaluateRawContent` helper method for consistent text evaluation - Update `#evaluateScopedContent` to use the shared helper, reducing duplication - Add 8 comprehensive test cases for nested scoped macros in arguments - Enhance JSDoc documentation for EvaluationContext text parameter * Fix `{{pick}}` macro to use global document offset for deterministic seeding - Replace `range.startOffset` with `globalOffset` in pick macro handler for consistent position-based seeding - Add `contextOffset` to EvaluationContext to track base offset from original document (starts at 0 for top-level) - Calculate `globalOffset` as `contextOffset + range.startOffset` when building MacroCall objects - Thread `contextOffset` through evaluation pipeline: MacroEngine → MacroCstWalker → all evaluation * Fix typo in MacroCstWalker JSDoc comment and thread contextOffset through evaluateDocument - Correct JSDoc typo: "rull macro text" → "full macro text" - Destructure `contextOffset` from options in `evaluateDocument` method - Pass `contextOffset` to EvaluationContext instead of hardcoded 0

3047045d3722bb7f6e59d7f98f1e6f3c1b33c59b

Wolfsblvt <wolfsblvt@gmail.com>

Signed

Parents: 8a32b72dfea21a678864c561cd74ae3c4caab82e

public/scripts/macros/definitions/core-macros.js+9 -2 Viewed

         description: 'Picks a random item from a list, but keeps the choice stable for a given chat and macro position.',
         returns: 'Stable randomly selected item from the list.',
         exampleUsage: ['{{pick::blonde::brown::red::black::blue}}'],
-        handler: ({ list, range, env }) => {
+        handler: ({ list, globalOffset, env }) => {
             // Handle old legacy cases, where we have to split the list manually
             if (list.length === 1) {
                 list = readSingleArgsRandomList(list[0]);

                 return '';
+            }
+            // NOTE:
+            // When changing the hashing logic, make sure to update unit test functionality
+            // in registerTestablePick() to be identical.
             const chatIdHash = getChatIdHash();
             // Use the full original input string for deterministic behavior
             const rawContentHash = env.contentHash;
-            const offset = typeof range?.startOffset === 'number' ? range.startOffset : 0;
+            // Use globalOffset for deterministic seeding - this ensures identical macros
+            // at different positions in the document produce different results, even when
+            // nested inside arguments or scoped content
+            const offset = globalOffset;
             const combinedSeedString = `${chatIdHash}-${rawContentHash}-${offset}`;
             const finalSeed = getStringHash(combinedSeedString);

public/scripts/macros/engine/MacroCstWalker.js+107 -92 Viewed

  * @property {string} rawInner
  * @property {string} rawWithBraces
  * @property {string[]} rawArgs
- * @property {{ startOffset: number, endOffset: number }} range
+ * @property {{ startOffset: number, endOffset: number }} range - Range relative to the current evaluation context's text.
+ * @property {number} globalOffset - The offset of this macro in the original top-level document.
+ *           This combines the context's base offset with the local range. Use this for deterministic
+ *           seeding (e.g., in {{pick}}) to ensure identical macros at different positions produce different results.
  * @property {CstNode} cstNode
  */

  */
 /**
+ * Context passed through the CST evaluation process.
+ *
  * @typedef {Object} EvaluationContext
- * @property {string} text
+ * @property {string} text - The text being evaluated at the current level. This is NOT the same as env.content.
- * @property {MacroEnv} env
+ *           At the top level, this is the full document text. When evaluating nested content (arguments or scoped
- * @property {(call: MacroCall) => string} resolveMacro
+ *           content), this is the substring being evaluated. CST node positions are always relative to this text.
+ *
+ *           - Careful, this also means when resolving macros inside macro arguments, this will NOT be the text of
+ *           the argument currently being resolved, but the full macro text with identifier and all macros.
+ * @property {number} contextOffset - Base offset from the original top-level document. At the top level this is 0.
+ *           When re-parsing nested content (arguments/scoped), this is set to the substring's start position in
+ *           the original document. Used to calculate globalOffset for macros that need deterministic positioning.
+ * @property {MacroEnv} env - The macro environment containing context like user/char names, variables, and the
+ *           original full content (env.content). This remains constant throughout the evaluation.
+ * @property {(call: MacroCall) => string} resolveMacro - Callback to resolve a macro call to its result string.
  * @property {(content: string, options?: { trimIndent?: boolean }) => string} trimContent - Shared utility function that trims scoped content with optional indentation dedent.
  */

      * @returns {string}
      */
     evaluateDocument(options) {
-        const { text, cst, env, resolveMacro, trimContent } = options;
+        const { text, cst, contextOffset, env, resolveMacro, trimContent } = options;
         if (typeof text !== 'string') {
             throw new Error('MacroCstWalker.evaluateDocument: text must be a string');

+        }
         /** @type {EvaluationContext} */
-        const context = { text, env, resolveMacro, trimContent };
+        const context = { text, contextOffset, env, resolveMacro, trimContent };
         let items = this.#collectDocumentItems(cst);
         // Process scoped macros: find opening/closing pairs and merge them

      * @returns {string}
      */
     #evaluateMacroNode(macroNode, context, scopedContent) {
-        const { text, env, resolveMacro, trimContent } = context;
+        const { text, contextOffset, env, resolveMacro, trimContent } = context;
         const children = macroNode.children || {};

             rawWithBraces: text.slice(range.startOffset, range.endOffset + 1),
             rawArgs,
             range,
+            globalOffset: contextOffset + range.startOffset,
             cstNode: macroNode,
             env,
         };

      * @returns {string}
      */
     #evaluateVariableExpr(macroNode, variableExprNode, context) {
-        const { text, env, resolveMacro } = context;
+        const { text, contextOffset, env, resolveMacro } = context;
         const children = macroNode.children || {};
         const varChildren = variableExprNode.children || {};

             rawWithBraces: text.slice(range.startOffset, range.endOffset + 1),
             rawArgs: args,
             range,
+            globalOffset: contextOffset + range.startOffset,
             cstNode: macroNode,
             env,
         };

      * Evaluates a single argument node by resolving nested macros and reconstructing
      * the original argument text.
+     *
-     * @param {CstNode} argNode
+     * This method extracts the argument's raw text and re-parses it to properly
-     * @param {EvaluationContext} context
+     * handle scoped macros (opening/closing tag pairs) that may appear within
-     * @returns {string}
+     * the argument content.
+     *
+     * @param {CstNode} argNode - The argument CST node to evaluate.
+     * @param {EvaluationContext} context - The evaluation context containing the parent document's text and environment.
+     * @returns {string} The evaluated argument with all nested macros (including scoped ones) resolved.
      */
     #evaluateArgumentNode(argNode, context) {
         const location = this.#getArgumentLocation(argNode);

             return '';
+        }
-        const { text } = context;
+        const { text, contextOffset } = context;
+        const rawContent = text.slice(location.startOffset, location.endOffset + 1);
-        const nestedMacros = /** @type {CstNode[]} */ ((argNode.children || {}).macro || []);
+        // Calculate the new base offset: parent's contextOffset + this argument's start position
+        const newContextOffset = contextOffset + location.startOffset;
-        // If there are no nested macros, we can just return the original text
+        // Use the shared helper to evaluate the content, which handles scoped macros
-        if (nestedMacros.length === 0) {
+        return this.#evaluateRawContent(rawContent, newContextOffset, context);
-            return text.slice(location.startOffset, location.endOffset + 1);
+    }
+    /**
+     * Evaluates a text content string by parsing it and resolving all macros,
+     * including scoped macro pairs (opening/closing tags).
+     *
+     * This is the core helper used by both argument evaluation and scoped content
+     * evaluation to ensure consistent handling of nested and scoped macros.
+     *
+     * @param {string} rawContent - The raw text content to evaluate.
+     * @param {number} newContextOffset - The offset of rawContent's start position in the original top-level document.
+     * @param {EvaluationContext} context - The parent evaluation context (used for env, resolveMacro, trimContent).
+     * @returns {string} The evaluated content with all macros resolved.
+     */
+    #evaluateRawContent(rawContent, newContextOffset, context) {
+        // If empty, return as-is
+        if (!rawContent) {
+            return '';
+        }
-        // If there are macros, evaluate them one by one in appearing order, inside the argument, before we return the resolved argument
+        // Re-evaluate the content to find all nested macros including scoped pairs
-        const nestedWithRange = nestedMacros.map(node => ({
+        // We need to parse and evaluate this content as if it were a standalone document
-            node,
+        const { cst } = MacroParser.parseDocument(rawContent);
-            range: this.#getMacroRange(node),
-        }));
-        nestedWithRange.sort((a, b) => a.range.startOffset - b.range.startOffset);
+        // If parsing fails, return the raw content
+        if (!cst || typeof cst !== 'object' || !cst.children) {
+            return rawContent;
+        }
+        // Create a new context with the content as the text and updated contextOffset
+        // This is important: positions in the parsed CST are relative to rawContent,
+        // but contextOffset tracks the absolute position in the original document
+        /** @type {EvaluationContext} */
+        const contentContext = { ...context, text: rawContent, contextOffset: newContextOffset };
+        // Collect items and process scoped macros
+        let items = this.#collectDocumentItems(cst);
+        items = this.#processScopedMacros(items, rawContent);
+        // If no items, return raw content
+        if (items.length === 0) {
+            return rawContent;
+        }
+        // Evaluate items in order
         let result = '';
-        let cursor = location.startOffset;
+        let cursor = 0;
-        for (const entry of nestedWithRange) {
+        for (const item of items) {
-            if (entry.range.startOffset < cursor) {
+            if (item.startOffset > cursor) {
-                continue;
+                result += rawContent.slice(cursor, item.startOffset);
+            }
-            result += text.slice(cursor, entry.range.startOffset);
+            if (item.type === 'plaintext') {
-            result += this.#evaluateMacroNode(entry.node, context);
+                result += rawContent.slice(item.startOffset, item.endOffset + 1);
-            cursor = entry.range.endOffset + 1;
+                cursor = item.endOffset + 1;
+            } else if (item.keepRaw) {
+                // Unmatched closing macros stay as raw text
+                result += rawContent.slice(item.startOffset, item.endOffset + 1);
+                cursor = item.endOffset + 1;
+            } else {
+                result += this.#evaluateMacroNode(item.node, contentContext, item.scopedContent);
+                // If this macro has scoped content, skip past the closing macro
+                if (item.scopedContent && item.scopedContent.closingEndOffset > item.endOffset) {
+                    cursor = item.scopedContent.closingEndOffset + 1;
+                } else {
+                    cursor = item.endOffset + 1;
+                }
+            }
+        }
-        if (cursor <= location.endOffset) {
+        if (cursor < rawContent.length) {
-            result += text.slice(cursor, location.endOffset + 1);
+            result += rawContent.slice(cursor);
+        }
         return result;

      * This resolves any nested macros within the scoped content.
+     *
      * @param {{ startOffset: number, endOffset: number }} scopedContent - The range of the scoped content.
-     * @param {EvaluationContext} context - The evaluation context.
+     * @param {EvaluationContext} context - The evaluation context. The `text` property contains the parent
+     *        document text, and offsets in scopedContent are relative to that parent text.
      * @returns {string} - The evaluated scoped content with nested macros resolved.
      */
     #evaluateScopedContent(scopedContent, context) {
-        const { text, env, resolveMacro, trimContent } = context;
+        const { text, contextOffset } = context;
         const { startOffset, endOffset } = scopedContent;
         // Extract the raw content between opening and closing tags
         const rawContent = text.slice(startOffset, endOffset + 1);
-        // If empty, return empty string
+        // Calculate the new base offset: parent's contextOffset + this scoped content's start position
-        if (!rawContent) {
+        const newContextOffset = contextOffset + startOffset;
-            return '';
-        }
-        // Re-evaluate the scoped content to resolve any nested macros
-        // We need to parse and evaluate this content as if it were a standalone document
-        const { cst: scopedCst } = MacroParser.parseDocument(rawContent);
-        // If parsing fails, return the raw content
-        if (!scopedCst || typeof scopedCst !== 'object' || !scopedCst.children) {
-            return rawContent;
-        }
-        // Create a new context with the scoped content text
-        /** @type {EvaluationContext} */
-        const scopedContext = { text: rawContent, env, resolveMacro, trimContent };
-        // Collect items from the scoped content CST
-        let items = this.#collectDocumentItems(scopedCst);
-        // Process any nested scoped macros within this content
-        items = this.#processScopedMacros(items, rawContent);
-        // Evaluate the items
-        if (items.length === 0) {
-            return rawContent;
-        }
-        let result = '';
-        let cursor = 0;
-        for (const item of items) {
+        // Use the shared helper to evaluate the content
-            if (item.startOffset > cursor) {
+        return this.#evaluateRawContent(rawContent, newContextOffset, context);
-                result += rawContent.slice(cursor, item.startOffset);
-            }
-            if (item.type === 'plaintext') {
-                result += rawContent.slice(item.startOffset, item.endOffset + 1);
-                cursor = item.endOffset + 1;
-            } else if (item.keepRaw) {
-                // Unmatched closing macros stay as raw text
-                result += rawContent.slice(item.startOffset, item.endOffset + 1);
-                cursor = item.endOffset + 1;
-            } else {
-                result += this.#evaluateMacroNode(item.node, scopedContext, item.scopedContent);
-                // If this macro has scoped content, skip past the closing macro
-                if (item.scopedContent && item.scopedContent.closingEndOffset > item.endOffset) {
-                    cursor = item.scopedContent.closingEndOffset + 1;
-                } else {
-                    cursor = item.endOffset + 1;
-                }
-            }
-        }
-        if (cursor < rawContent.length) {
-            result += rawContent.slice(cursor);
-        }
-        return result;
+    }
     // ========================================================================

public/scripts/macros/engine/MacroEngine.js+1 -0 Viewed

         try {
             evaluated = MacroCstWalker.evaluateDocument({
                 text: preProcessed,
+                contextOffset: 0,
                 cst,
                 env: safeEnv,
                 resolveMacro: this.#resolveMacro.bind(this),

public/scripts/macros/engine/MacroRegistry.js+6 -2 Viewed

  * @property {string} rawOriginal - The original full macro text including braces, before any resolution.
  * @property {string[]} rawArgs - The original arguments passed to the macro (always unresolved).
  * @property {MacroEnv} env
- * @property {CstNode|null} cstNode
+ * @property {CstNode} cstNode
- * @property {{ startOffset: number, endOffset: number }|null} range
+ * @property {{ startOffset: number, endOffset: number }} range - Range relative to the current evaluation context's text.
+ * @property {number} globalOffset - The offset of this macro in the original top-level document.
+ *           This combines the context's base offset with the local range. Use this for deterministic
+ *           seeding (e.g., in {{pick}}) to ensure identical macros at different positions produce different results.
  * @property {(value: any) => string} normalize - Normalize function to use on unsure macro results to make sure they return strings as expected.
  * @property {(content: string, options?: { trimIndent?: boolean }) => string} trimContent - Trims scoped content with optional indentation dedent. Defaults to trimming indentation.
  * @property {(text: string) => string} resolve - Evaluates macros in the given text using the same environment. Use when delayArgResolution is true.

             env: call.env,
             cstNode: call.cstNode,
             range: call.range,
+            globalOffset: call.globalOffset,
             normalize: MacroEngine.normalizeMacroResult.bind(MacroEngine),
             trimContent: MacroEngine.trimScopedContent.bind(MacroEngine),
             resolve: (text) => MacroEngine.evaluate(text, call.env),

tests/frontend/MacroEngine.e2e.js+218 -16 Viewed

     });
     test.describe('Deterministic pick macro', () => {
-        test('should return stable results for the same chat and content', async ({ page }) => {
+        /** Fixed chat ID hash used across all pick tests for deterministic behavior */
-            // Simulate a consistent chat id hash
+        const TEST_CHAT_ID_HASH = 123456;
-            let originalHash;
-            await page.evaluate(async ([originalHash]) => {
+        /**
+         * Registers a testable pick macro that returns the seed string instead of the picked value.
+         * This allows tests to verify that different macro positions produce different seeds.
+         *
+         * @param {import('@playwright/test').Page} page
+         */
+        async function registerTestablePick(page) {
+            await page.evaluate(async () => {
+                /** @type {import('../../public/scripts/macros/engine/MacroRegistry.js')} */
+                const { MacroRegistry, MacroCategory } = await import('./scripts/macros/engine/MacroRegistry.js');
+                /** @type {import('../../public/scripts/utils.js')} */
+                const { getStringHash } = await import('./scripts/utils.js');
+                /** @type {import('../../public/script.js')} */
+                const { chat_metadata } = await import('./script.js');
+                /** @type {import('../../public/lib.js')} */
+                const { seedrandom } = await import('./lib.js');
+                // Only register once
+                if (MacroRegistry.getMacro('testablePick')) return;
+                MacroRegistry.registerMacro('testablePick', {
+                    category: MacroCategory.RANDOM,
+                    list: true,
+                    description: 'Test version of pick that returns the seed string for verification.',
+                    handler: ({ list, globalOffset, env }) => {
+                        const chatIdHash = chat_metadata.chat_id_hash ?? 0;
+                        const rawContentHash = env.contentHash;
+                        const offset = globalOffset;
+                        const combinedSeedString = `${chatIdHash}-${rawContentHash}-${offset}`;
+                        // Return both the seed and what would be picked for validation
+                        const finalSeed = getStringHash(combinedSeedString);
+                        const rng = seedrandom(String(finalSeed));
+                        const randomIndex = Math.floor(rng() * list.length);
+                        return `seed:${combinedSeedString}|pick:${list[randomIndex]}`;
+                    },
+                });
+            });
+        }
+        test.beforeEach(async ({ page }) => {
+            // Set consistent chat ID hash for all tests
+            await page.evaluate(async (hash) => {
                 /** @type {import('../../public/script.js')} */
                 const { chat_metadata } = await import('./script.js');
-                originalHash = chat_metadata.chat_id_hash;
+                chat_metadata.chat_id_hash = hash;
-                chat_metadata.chat_id_hash = 123456;
+            }, TEST_CHAT_ID_HASH);
-            }, [originalHash]);
+        });
+        test('should return stable results for the same chat and content', async ({ page }) => {
             const input = 'Choices: {{pick::red::green::blue}}, {{pick::red::green::blue}}.';
             const output1 = await evaluateWithEngine(page, input);
             const output2 = await evaluateWithEngine(page, input);
-            // Deterministic: same chat and same content should yield identical output.
+            // Deterministic: same chat and same content should yield identical output
             expect(output1).toBe(output2);
-            // Sanity check: both picks should resolve to one of the provided options.
+            // Sanity check: both picks should resolve to one of the provided options
             const match = output1.match(/Choices: ([^,]+), ([^.]+)\./);
             expect(match).not.toBeNull();
             if (!match) return;
             const first = match[1].trim();

             expect(options.includes(first)).toBeTruthy();
             expect(options.includes(second)).toBeTruthy();
+        });
-            // Restore original hash
+        test('should use different seeds for identical picks at different positions', async ({ page }) => {
-            await page.evaluate(async ([originalHash]) => {
+            await registerTestablePick(page);
-                /** @type {import('../../public/script.js')} */
-                const { chat_metadata } = await import('./script.js');
+            const output = await page.evaluate(async () => {
-                chat_metadata.chat_id_hash = originalHash;
+                /** @type {import('../../public/scripts/macros/engine/MacroEngine.js')} */
-            }, [originalHash]);
+                const { MacroEngine } = await import('./scripts/macros/engine/MacroEngine.js');
+                /** @type {import('../../public/scripts/macros/engine/MacroEnvBuilder.js')} */
+                const { MacroEnvBuilder } = await import('./scripts/macros/engine/MacroEnvBuilder.js');
+                const input = '{{testablePick::A::B::C}}###{{testablePick::A::B::C}}';
+                const env = MacroEnvBuilder.buildFromRawEnv({ content: input });
+                return MacroEngine.evaluate(input, env);
+            });
+            const parts = output.split('###');
+            expect(parts.length).toBe(2);
+            // Extract seeds from both results
+            const seed1 = parts[0].match(/seed:([^|]+)/)?.[1];
+            const seed2 = parts[1].match(/seed:([^|]+)/)?.[1];
+            expect(seed1).toBeTruthy();
+            expect(seed2).toBeTruthy();
+            // Seeds must be different because the macros are at different positions
+            expect(seed1).not.toBe(seed2);
+            // Verify picked values are valid options
+            const pick1 = parts[0].match(/pick:(\w+)/)?.[1];
+            const pick2 = parts[1].match(/pick:(\w+)/)?.[1];
+            const options = ['A', 'B', 'C'];
+            expect(options.includes(pick1 ?? '')).toBeTruthy();
+            expect(options.includes(pick2 ?? '')).toBeTruthy();
+        });
+        test('should use different seeds for identical picks inside different scoped macros at the same offset', async ({ page }) => {
+            await registerTestablePick(page);
+            // Key regression test: picks inside scoped content must use global offsets
+            const output = await page.evaluate(async () => {
+                /** @type {import('../../public/scripts/macros/engine/MacroEngine.js')} */
+                const { MacroEngine } = await import('./scripts/macros/engine/MacroEngine.js');
+                /** @type {import('../../public/scripts/macros/engine/MacroEnvBuilder.js')} */
+                const { MacroEnvBuilder } = await import('./scripts/macros/engine/MacroEnvBuilder.js');
+                // Two identical pick macros inside different setvar scopes
+                // Before the fix, both would get startOffset=0 relative to their argument
+                // After the fix, they get different globalOffset values
+                const input = '{{setvar::first}}{{testablePick::A::B::C}}{{/setvar}}{{setvar::second}}{{testablePick::A::B::C}}{{/setvar}}{{.first}}###{{.second}}';
+                const env = MacroEnvBuilder.buildFromRawEnv({ content: input });
+                return MacroEngine.evaluate(input, env);
+            });
+            const parts = output.split('###');
+            expect(parts.length).toBe(2);
+            const seed1 = parts[0].match(/seed:([^|]+)/)?.[1];
+            const seed2 = parts[1].match(/seed:([^|]+)/)?.[1];
+            expect(seed1).toBeTruthy();
+            expect(seed2).toBeTruthy();
+            // Seeds must be different - this is the key assertion for the fix
+            expect(seed1).not.toBe(seed2);
+        });
+        test('should use different seeds for identical picks in inline arguments', async ({ page }) => {
+            await registerTestablePick(page);
+            const output = await page.evaluate(async () => {
+                /** @type {import('../../public/scripts/macros/engine/MacroEngine.js')} */
+                const { MacroEngine } = await import('./scripts/macros/engine/MacroEngine.js');
+                /** @type {import('../../public/scripts/macros/engine/MacroEnvBuilder.js')} */
+                const { MacroEnvBuilder } = await import('./scripts/macros/engine/MacroEnvBuilder.js');
+                // Two identical pick macros inside different setvar inline arguments
+                const input = '{{setvar::first::{{testablePick::A::B::C}}}}{{setvar::second::{{testablePick::A::B::C}}}}{{.first}}###{{.second}}';
+                const env = MacroEnvBuilder.buildFromRawEnv({ content: input });
+                return MacroEngine.evaluate(input, env);
+            });
+            const parts = output.split('###');
+            expect(parts.length).toBe(2);
+            const seed1 = parts[0].match(/seed:([^|]+)/)?.[1];
+            const seed2 = parts[1].match(/seed:([^|]+)/)?.[1];
+            expect(seed1).toBeTruthy();
+            expect(seed2).toBeTruthy();
+            // Seeds must be different due to different global offsets
+            expect(seed1).not.toBe(seed2);
+        });
+        test('should maintain stability across evaluations for picks in scoped content', async ({ page }) => {
+            // Picks inside scoped content should still be deterministic (same result each time)
+            const outputs = await page.evaluate(async () => {
+                /** @type {import('../../public/scripts/macros/engine/MacroEngine.js')} */
+                const { MacroEngine } = await import('./scripts/macros/engine/MacroEngine.js');
+                /** @type {import('../../public/scripts/macros/engine/MacroEnvBuilder.js')} */
+                const { MacroEnvBuilder } = await import('./scripts/macros/engine/MacroEnvBuilder.js');
+                const input = '{{setvar::val}}{{pick::X::Y::Z}}{{/setvar}}{{.val}}';
+                const env1 = MacroEnvBuilder.buildFromRawEnv({ content: input });
+                const env2 = MacroEnvBuilder.buildFromRawEnv({ content: input });
+                const result1 = MacroEngine.evaluate(input, env1);
+                const result2 = MacroEngine.evaluate(input, env2);
+                return [result1, result2];
+            });
+            // Same input should produce same output (deterministic)
+            expect(outputs[0]).toBe(outputs[1]);
+            // Should be one of the valid options
+            expect(['X', 'Y', 'Z'].includes(outputs[0])).toBeTruthy();
         });
     });

             const output = await evaluateWithEngine(page, input);
             expect(output).toBe('middle[first][second]');
         });
+        test.describe('scoped macros nested inside arguments', () => {
+            test('should resolve scoped macro inside another macro argument', async ({ page }) => {
+                // {{reverse}}hello{{/reverse}} inside setvar's value argument should resolve first
+                const input = '{{setvar::testvar::{{reverse}}hello{{/reverse}}}} {{getvar::testvar}}';
+                const output = await evaluateWithEngine(page, input);
+                expect(output).toBe(' olleh');
+            });
+            test('should resolve scoped if macro inside setvar argument', async ({ page }) => {
+                // {{if true}}true branch{{/if}} inside setvar should resolve to "true branch"
+                const input = '{{setvar::testvar::{{if true}}true branch{{/if}}}} {{getvar::testvar}}';
+                const output = await evaluateWithEngine(page, input);
+                expect(output).toBe(' true branch');
+            });
+            test('should resolve scoped if/else macro inside setvar argument', async ({ page }) => {
+                const input = '{{setvar::testvar::{{if 0}}wrong{{else}}correct{{/if}}}} {{getvar::testvar}}';
+                const output = await evaluateWithEngine(page, input);
+                expect(output).toBe(' correct');
+            });
+            test('should resolve multiple scoped macros inside single argument', async ({ page }) => {
+                // Two scoped macros in the same argument
+                const input = '{{setvar::testvar::{{reverse}}ab{{/reverse}}-{{reverse}}cd{{/reverse}}}} {{getvar::testvar}}';
+                const output = await evaluateWithEngine(page, input);
+                expect(output).toBe(' ba-dc');
+            });
+            test('should resolve deeply nested scoped macros in arguments', async ({ page }) => {
+                // Scoped macro inside scoped macro inside argument
+                const input = '{{setvar::outer::{{setvar::inner::{{reverse}}xyz{{/reverse}}}}{{getvar::inner}}}} {{getvar::outer}}';
+                const output = await evaluateWithEngine(page, input);
+                expect(output).toBe(' zyx');
+            });
+            test('should resolve scoped macro with text before and after in argument', async ({ page }) => {
+                const input = '{{setvar::testvar::before {{reverse}}mid{{/reverse}} after}} {{getvar::testvar}}';
+                const output = await evaluateWithEngine(page, input);
+                expect(output).toBe(' before dim after');
+            });
+            test('should handle scoped macro inside first argument when macro has multiple args', async ({ page }) => {
+                // setvar has two args: name and value. Test scoped in value position.
+                const input = '{{setvar::myvar::prefix-{{reverse}}abc{{/reverse}}-suffix}}{{getvar::myvar}}';
+                const output = await evaluateWithEngine(page, input);
+                expect(output).toBe('prefix-cba-suffix');
+            });
+            test('should handle multiline scoped content inside argument', async ({ page }) => {
+                const input = '{{setvar::testvar::{{if true}}\ntrue\nbranch\n{{/if}}}} {{getvar::testvar}}';
+                const output = await evaluateWithEngine(page, input);
+                expect(output).toBe(' true\nbranch');
+            });
+        });
     });
     test.describe('{{if}} conditional macro', () => {