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, rangeglobalOffset, 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 - 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, contextOffset, env, resolveMacro, trimContent } = options;
         if (typeof text !== 'string') {
             throw new Error('MacroCstWalker.evaluateDocument: text must be a string');

+        }
         /** @type {EvaluationContext} */
         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, 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, 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, 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 thereUse arethe noshared nestedhelper macros,to weevaluate canthe justcontent, returnwhich thehandles originalscoped textmacros
 -        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.startOffset0;
         for (const entryitem of nestedWithRangeitems) {
             if (entry.rangeitem.startOffset <> cursor) {
 -                continue;
 +                result += rawContent.slice(cursor, item.startOffset);
+            }
 -            result += text.slice(cursor, entry.range.startOffset);
 +            if (item.type === 'plaintext') {
                             result += thisrawContent.#evaluateMacroNodeslice(entryitem.nodestartOffset, contextitem.endOffset + 1);
                             cursor = entry.rangeitem.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 <= locationrawContent.endOffsetlength) {
             result += textrawContent.slice(cursor, location.endOffset + 1);
+        }
         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. 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, trimContentcontextOffset } = 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 {{ startOffset: number, endOffset: number }|null} 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 = 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.
             expect(output1).toBe(output2);
             // 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', () => {