Macros 2.0 (v0.6.6) - STscript compatibility (#4957) * Bypass REPLACE_GETVAR with experimental parser enabled * (wip) macro-2.0 replacer in STscript parser * Add support for MacroDefinitionOptions format in dynamic macros - Add DynamicMacroValue typedef supporting string, function, or MacroDefinitionOptions object - Extract macro definition building logic into MacroRegistry.buildMacroDefFromOptions() method - Update MacroEngine to detect and handle three dynamic macro formats: 1. string - direct value, no args allowed 2. function - handler function, no args allowed (legacy) 3. MacroDefinitionOptions object - full definition with handler, args, type * Implement dynamic macro replacers * Remove global typedef * Use unique closure boundary * Add e2e tests for MacroSlashCommands * Update public/scripts/macros/engine/MacroEngine.js Co-authored-by: Wolfsblvt <wolfsblvt@gmail.com> * Use strict args array match * Update public/scripts/macros/engine/MacroEngine.js --------- Co-authored-by: Wolfsblvt <wolfsblvt@gmail.com>

7331dba056583f4fd1118686ed2fe6fbea5785e6

Cohee <18619528+Cohee1207@users.noreply.github.com>

Signed

Parents: 293ee0a31009f6df44595ca1916c6c7c2e6f240c

public/script.js+1 -1 Viewed

  * @param {string} [options.original] - The original message for {{original}} substitution.
  * @param {string} [options.groupOverride] - The group members list for {{group}} substitution.
  * @param {boolean} [options.replaceCharacterCard=true] - Whether to replace character card macros.
- * @param {Record<string,string|MacroHandler>} [options.dynamicMacros={}] - Additional environment variables as dynamic macros for substitution. Registered as macro functions.
+ * @param {Record<string, import('./scripts/macros/engine/MacroEnv.types.js').DynamicMacroValue>} [options.dynamicMacros={}] - Additional environment variables as dynamic macros for substitution. Registered as macro functions.
  * @param {(x: string) => string} [options.postProcessFn=(x) => x] - Post-processing function for each substituted macro.
  * @returns {string} The string with substituted parameters.
  */

public/scripts/macros/engine/MacroEngine.js+34 -20 Viewed

 import { MacroParser } from './MacroParser.js';
 import { MacroCstWalker } from './MacroCstWalker.js';
-import { MacroRegistry } from './MacroRegistry.js';
+import { MacroRegistry, MacroValueType } from './MacroRegistry.js';
 import { logMacroGeneralError, logMacroInternalError, logMacroRuntimeWarning, logMacroSyntaxWarning } from './MacroDiagnostics.js';
 import { ELSE_MARKER } from '../definitions/core-macros.js';
 /** @typedef {import('./MacroCstWalker.js').MacroCall} MacroCall */
 /** @typedef {import('./MacroEnv.types.js').MacroEnv} MacroEnv */
+/** @typedef {import('./MacroRegistry.js').MacroDefinitionOptions} MacroDefinitionOptions */
 /** @typedef {import('./MacroRegistry.js').MacroDefinition} MacroDefinition */
 /**

         // First check if this is a dynamic macro to use. If so, we will create a temporary macro definition for it and use that over any registered macro.
         // Dynamic macro keys are normalized to lowercase for case-insensitive matching.
-        /** @type {MacroDefinition?} */
+        /** @type {MacroDefinition|null} */
         let defOverride = null;
         const nameLower = name.toLowerCase();
         if (Object.hasOwn(env.dynamicMacros, nameLower)) {
             const impl = env.dynamicMacros[nameLower];
-            defOverride = {
-                name,
+            // Dynamic macros support three formats:
-                aliases: [],
+            // 1. string - direct value, no args allowed
+            // 2. function - handler function, no args allowed (legacy behavior)
+            // 3. MacroDefinitionOptions object - full definition with handler, args, type validation, etc.
+            // Check if this looks like a MacroDefinitionOptions object (has handler property)
+            const looksLikeOptions = impl && typeof impl === 'object' &&
+                'handler' in impl && typeof impl.handler === 'function';
+            if (looksLikeOptions) {
+                // Case 3: MacroDefinitionOptions - use the full definition builder
+                try {
+                    const options = /** @type {MacroDefinitionOptions} */ (impl);
+                    defOverride = MacroRegistry.buildMacroDefFromOptions(name, options);
+                } catch (error) {
+                    // If building fails, log warning and fall through to check registered macros
+                    logMacroRuntimeWarning({ message: `Dynamic macro "${name}" has invalid options: ${error.message}`, call });
+                }
+            } else if (['string', 'number', 'boolean', 'function'].includes((typeof impl))) {
+                // Case 1 & 2: string or handler function
+                if (['number', 'boolean'].includes(typeof impl)) {
+                    logMacroRuntimeWarning({ message: `Dynamic macro "${name}" uses unsupported number/boolean format.`, call });
+                }
+                defOverride = MacroRegistry.buildMacroDefFromOptions(name, {
+                    handler: typeof impl === 'function' ? impl : () => String(impl ?? ''),
                     category: 'dynamic',
                     description: 'Dynamic macro',
-                minArgs: 0,
+                    returnType: MacroValueType.STRING,
-                maxArgs: 0,
+                });
-                unnamedArgDefs: [],
+            } else {
-                list: null,
+                logMacroRuntimeWarning({ message: `Dynamic macro "${name}" is not defined correctly (must be string, a handler function, or a macro def options object with handler property).`, call });
-                strictArgs: true, // Fail dynamic macros if they are called with arguments
+            }
-                returns: null,
-                returnType: 'string',
-                displayOverride: null,
-                exampleUsage: [],
-                source: { name: 'dynamic', isExtension: false, isThirdParty: false },
-                aliasOf: null,
-                aliasVisible: null,
-                delayArgResolution: false,
-                handler: typeof impl === 'function' ? impl : () => impl,
-            };
+        }
         // If not, check if the macro exists and is registered

public/scripts/macros/engine/MacroEnv.types.js+10 -1 Viewed

  */
 /** @typedef {import('./MacroRegistry.js').MacroHandler} MacroHandler */
+/** @typedef {import('./MacroRegistry.js').MacroDefinitionOptions} MacroDefinitionOptions */
+/**
+ * A dynamic macro value can be:
+ * - A string (direct value)
+ * - A MacroHandler function (resolved at runtime)
+ * - A MacroDefinitionOptions object (full macro definition with handler, args, etc.)
+ * @typedef {string | MacroHandler | MacroDefinitionOptions} DynamicMacroValue
+ */
 /**
  * @typedef {Object} MacroEnvNames

  * @property {MacroEnvCharacter} character
  * @property {MacroEnvSystem} system
  * @property {MacroEnvFunctions} functions
- * @property {Object<string, string|MacroHandler>} dynamicMacros
+ * @property {Object<string, DynamicMacroValue>} dynamicMacros
  * @property {Record<string, unknown>} extra
  */

public/scripts/macros/engine/MacroEnvBuilder.js+1 -1 Viewed

  * @property {string|null} [original]
  * @property {string|null} [groupOverride]
  * @property {boolean} [replaceCharacterCard]
- * @property {Record<string, any>|null} [dynamicMacros]
+ * @property {Record<string, import('./MacroEnv.types.js').DynamicMacroValue>|null} [dynamicMacros]
  * @property {(value: string) => string} [postProcessFn]
  */

public/scripts/macros/engine/MacroRegistry.js+207 -185 Viewed

         name = typeof name === 'string' ? name.trim() : String(name);
         try {
+            const nameKey = name.toLowerCase();
+            if (this.#macros.has(nameKey)) {
+                logMacroRegisterWarning({ macroName: name, message: `Macro "${name}" is already registered and will be overwritten.` });
+            }
+            // Detect extension/third-party status from call stack
+            const { isExtension, isThirdParty, source } = detectMacroSource();
+            // Build the definition using the shared helper
+            const definition = this.buildMacroDefFromOptions(name, options, {
+                source: { name: source, isExtension, isThirdParty },
+            });
+            this.#macros.set(nameKey, definition);
+            // Register alias entries pointing to the same definition
+            for (const { alias, visible } of definition.aliases) {
+                const aliasKey = alias.toLowerCase();
+                if (this.#macros.has(aliasKey)) {
+                    logMacroRegisterWarning({ macroName: name, message: `Alias "${alias}" for macro "${name}" overwrites an existing macro.` });
+                }
+                /** @type {MacroDefinition} */
+                const aliasEntry = {
+                    ...definition,
+                    name: alias, // The lookup name is the alias (preserves original casing for display)
+                    aliasOf: name,
+                    aliasVisible: visible,
+                };
+                this.#macros.set(aliasKey, aliasEntry);
+            }
+            return definition;
+        } catch (error) {
+            logMacroRegisterError({
+                message: `Failed to register macro "${name}". The macro will not be available.`,
+                macroName: name,
+                error,
+            });
+            return null;
+        }
+    }
+    /**
+     * Unregisters a macro.
+     *
+     * @param {string} name - Macro name (identifier).
+     * @returns {boolean} True if a macro was removed.
+     */
+    unregisterMacro(name) {
+        if (typeof name !== 'string' || !name.trim()) throw new Error('Macro name must be a non-empty string');
+        name = name.trim();
+        return this.#macros.delete(name.toLowerCase());
+    }
+    /**
+     * Checks whether a macro with the given name is registered.
+     *
+     * @param {string} name - Macro name (identifier).
+     * @returns {boolean}
+     */
+    hasMacro(name) {
+        if (typeof name !== 'string' || !name.trim()) return false;
+        name = name.trim();
+        return this.#macros.has(name.toLowerCase());
+    }
+    /**
+     * Returns the macro definition for a given name.
+     *
+     * @param {string} name - Macro name (identifier).
+     * @returns {MacroDefinition|undefined}
+     */
+    getMacro(name) {
+        if (typeof name !== 'string' || !name.trim()) return undefined;
+        name = name.trim();
+        return this.#macros.get(name.toLowerCase());
+    }
+    /**
+     * Returns the primary (non-alias) definition for a macro.
+     * If given an alias name, returns the primary definition it points to.
+     *
+     * @param {string} name - Macro name or alias.
+     * @returns {MacroDefinition|undefined}
+     */
+    getPrimaryMacro(name) {
+        const def = this.getMacro(name);
+        if (!def) return undefined;
+        return def.aliasOf ? this.getMacro(def.aliasOf) : def;
+    }
+    /**
+     * Returns an array of all registered macros.
+     *
+     * @param {Object} [options] - Filter options.
+     * @param {boolean} [options.excludeAliases=false] - If true, excludes alias entries (only returns primary definitions).
+     * @param {boolean} [options.excludeHiddenAliases=false] - If true, excludes alias entries where visible=false.
+     * @returns {MacroDefinition[]}
+     */
+    getAllMacros({ excludeAliases = false, excludeHiddenAliases = false } = {}) {
+        let macros = Array.from(this.#macros.values());
+        if (excludeAliases) {
+            macros = macros.filter(m => !m.aliasOf);
+        } else if (excludeHiddenAliases) {
+            macros = macros.filter(m => !m.aliasOf || m.aliasVisible !== false);
+        }
+        return macros;
+    }
+    /**
+     * Executes a macro for a given call.
+     *
+     * @param {MacroCall} call - Macro call information.
+     * @param {Object} [options] - Additional options.
+     * @param {MacroDefinition} [options.defOverride] - Override the macro definition.
+     * @returns {string}
+     */
+    executeMacro(call, { defOverride } = {}) {
+        const name = call.name;
+        const def = defOverride || this.getMacro(name);
+        if (!def) {
+            throw new Error(`Macro "${name}" is not registered`);
+        }
+        const args = Array.isArray(call.args) ? call.args : [];
+        if (!isArgsValid(def, args)) {
+            const expectedMin = def.list ? def.minArgs + def.list.min : def.minArgs;
+            const expectedMax = def.list && def.list.max !== null
+                ? def.maxArgs + def.list.max
+                : (def.list ? null : def.maxArgs);
+            const expectation = (() => {
+                if (expectedMax !== null && expectedMax !== expectedMin) return `between ${expectedMin} and ${expectedMax}`;
+                if (expectedMax !== null && expectedMax === expectedMin) return `${expectedMin}`;
+                return `at least ${expectedMin}`;
+            })();
+            const message = `Macro "${def.name}" called with ${args.length} unnamed arguments but expects ${expectation}.`;
+            if (def.strictArgs) {
+                throw createMacroRuntimeError({ message, call, def });
+            }
+            logMacroRuntimeWarning({ message, call, def });
+        }
+        // Compute unnamed args (required + optional, up to maxArgs)
+        const unnamedArgsCount = Math.min(args.length, def.maxArgs);
+        const unnamedArgsValues = args.slice(0, unnamedArgsCount);
+        const listValues = !def.list ? null : args.length > def.maxArgs ? args.slice(def.maxArgs) : [];
+        // Perform best-effort type validation for documented positional arguments.
+        // This can throw an error if the arguments are invalid.
+        validateArgTypes(call, def, unnamedArgsValues);
+        const namedArgs = null;
+        /** @type {MacroExecutionContext} */
+        const executionContext = {
+            name: def.name,
+            args,
+            unnamedArgs: unnamedArgsValues,
+            list: listValues,
+            namedArgs,
+            flags: call.flags,
+            isScoped: call.isScoped,
+            raw: call.rawInner,
+            rawOriginal: call.rawWithBraces,
+            rawArgs: call.rawArgs,
+            env: call.env,
+            cstNode: call.cstNode,
+            range: call.range,
+            normalize: MacroEngine.normalizeMacroResult.bind(MacroEngine),
+            trimContent: MacroEngine.trimScopedContent.bind(MacroEngine),
+            resolve: (text) => MacroEngine.evaluate(text, call.env),
+        };
+        const result = def.handler(executionContext);
+        return executionContext.normalize(result);
+    }
+    /**
+     * Builds a MacroDefinition from MacroDefinitionOptions.
+     *
+     * This is the core logic building the actual registered macro from an options object
+     * that has nearly everything as optional args.
+     *
+     * The options object is highly flexible and allows defining all aspects of a macro
+     * through optional properties. This method processes and validates the options to
+     * create a proper MacroDefinition that can be registered with the engine.
+     *
+     * Validation includes checking for required fields, validating argument definitions,
+     * and ensuring the handler function is callable.
+     * It throws errors for invalid configurations.
+     *
+     * @param {string} name - Macro name (identifier).
+     * @param {MacroDefinitionOptions} options - Macro definition options.
+     * @param {Object} [buildOptions] - Additional options for building.
+     * @param {MacroSource} [buildOptions.source] - Source information. Defaults to dynamic source.
+     * @returns {MacroDefinition} The built macro definition.
+     * @throws {Error} If validation fails.
+     */
+    buildMacroDefFromOptions(name, options, { source } = {}) {
+        name = typeof name === 'string' ? name.trim() : String(name);
         if (!isIdentifierValid(name)) throw new Error(`Macro name "${name}" is invalid. Must start with a letter, followed by alphanumeric characters or hyphens.`);
         if (!options || typeof options !== 'object') throw new Error(`Macro "${name}" options must be a non-null object.`);

@@ -222,7 +426,7 @@ class MacroRegistry {
222	const aliasName = aliasDef.alias.trim();	426	const aliasName = aliasDef.alias.trim();
223	if (!isIdentifierValid(aliasName)) throw new Error(`Macro "${name}" options.aliases[${i}].alias "${aliasName}" is invalid. Must start with a letter, followed by word chars or hyphens.`);	427	if (!isIdentifierValid(aliasName)) throw new Error(`Macro "${name}" options.aliases[${i}].alias "${aliasName}" is invalid. Must start with a letter, followed by word chars or hyphens.`);
224	if (aliasName.toLowerCase() === name.toLowerCase()) throw new Error(`Macro "${name}" options.aliases[${i}].alias cannot be the same as the macro name (insensitive).`);	428	if (aliasName.toLowerCase() === name.toLowerCase()) throw new Error(`Macro "${name}" options.aliases[${i}].alias cannot be the same as the macro name (insensitive).`);
225	const visible = aliasDef.visible !== false; // Default to true	429	const visible = aliasDef.visible !== false;
226	aliases.push({ alias: aliasName, visible });	430	aliases.push({ alias: aliasName, visible });
227	}	431	}
228	}	432	}

         let unnamedArgDefs = [];
         if (rawUnnamedArgs !== undefined) {
             if (Array.isArray(rawUnnamedArgs)) {
-                    // Parse array of argument definitions with optional support
                 let foundOptional = false;
                 unnamedArgDefs = rawUnnamedArgs.map((def, index) => {
                     if (!def || typeof def !== 'object') throw new Error(`Macro "${name}" options.unnamedArgs[${index}] must be an object when using argument definitions.`);
                     if (typeof def.name !== 'string' || !def.name.trim()) throw new Error(`Macro "${name}" options.unnamedArgs[${index}].name must be a non-empty string when using argument definitions.`);
-                        // Validate: no required args after optional
                     if (foundOptional && !def.optional) {
                         throw new Error(`Macro "${name}" options.unnamedArgs[${index}] is required but follows an optional argument. Optional args must be a suffix.`);
+                    }

                     return normalized;
                 });
-                    // Compute minArgs (required count) and maxArgs (total count)
                 maxArgs = unnamedArgDefs.length;
                 minArgs = unnamedArgDefs.findIndex(d => d.optional);
-                    if (minArgs === -1) minArgs = maxArgs; // No optional args, all are required
+                if (minArgs === -1) minArgs = maxArgs;
             } else if (typeof rawUnnamedArgs === 'number') {
                 if (!Number.isInteger(rawUnnamedArgs) || rawUnnamedArgs < 0) {
                     throw new Error(`Macro "${name}" options.unnamedArgs must be a non-negative integer when provided.`);

             returns = rawReturns || '<empty string>';
+        }
-            // Process and validate returnType (defaults to 'string')
         const validTypes = ['string', 'integer', 'number', 'boolean'];
         let returnType = /** @type {MacroValueType|MacroValueType[]} */ ('string');
         if (rawReturnType !== undefined && rawReturnType !== null) {
-                // Normalize to non-empty value or default
             returnType = Array.isArray(rawReturnType) && rawReturnType.length === 0 ? 'string' : rawReturnType;
-                // Validate all types
             const typesToValidate = Array.isArray(returnType) ? returnType : [returnType];
             if (typesToValidate.some(t => !validTypes.includes(t))) {
                 throw new Error(`Macro "${name}" options.returnType must be one of "string", "integer", "number", or "boolean" (or an array of these) when provided.`);

             delayArgResolution = rawDelayArgResolution;
+        }
-            const nameKey = name.toLowerCase();
-            if (this.#macros.has(nameKey)) {
-                logMacroRegisterWarning({ macroName: name, message: `Macro "${name}" is already registered and will be overwritten.` });
-            }
-            // Detect extension/third-party status from call stack
-            const { isExtension, isThirdParty, source } = detectMacroSource();
         /** @type {MacroDefinition} */
         const definition = {
             name: name,

             exampleUsage,
             delayArgResolution,
             handler,
-                source: {
+            source: source ?? { name: 'dynamic', isExtension: false, isThirdParty: false },
-                    name: source,
-                    isExtension,
-                    isThirdParty,
-                },
             aliasOf: null,
             aliasVisible: null,
         };
-            this.#macros.set(nameKey, definition);
-            // Register alias entries pointing to the same definition
-            for (const { alias, visible } of aliases) {
-                const aliasKey = alias.toLowerCase();
-                if (this.#macros.has(aliasKey)) {
-                    logMacroRegisterWarning({ macroName: name, message: `Alias "${alias}" for macro "${name}" overwrites an existing macro.` });
-                }
-                /** @type {MacroDefinition} */
-                const aliasEntry = {
-                    ...definition,
-                    name: alias, // The lookup name is the alias (preserves original casing for display)
-                    aliasOf: name,
-                    aliasVisible: visible,
-                };
-                this.#macros.set(aliasKey, aliasEntry);
-            }
         return definition;
-        } catch (error) {
-            logMacroRegisterError({
-                message: `Failed to register macro "${name}". The macro will not be available.`,
-                macroName: name,
-                error,
-            });
-            return null;
-        }
-    }
-    /**
-     * Unregisters a macro.
-     *
-     * @param {string} name - Macro name (identifier).
-     * @returns {boolean} True if a macro was removed.
-     */
-    unregisterMacro(name) {
-        if (typeof name !== 'string' || !name.trim()) throw new Error('Macro name must be a non-empty string');
-        name = name.trim();
-        return this.#macros.delete(name.toLowerCase());
-    }
-    /**
-     * Checks whether a macro with the given name is registered.
-     *
-     * @param {string} name - Macro name (identifier).
-     * @returns {boolean}
-     */
-    hasMacro(name) {
-        if (typeof name !== 'string' || !name.trim()) return false;
-        name = name.trim();
-        return this.#macros.has(name.toLowerCase());
-    }
-    /**
-     * Returns the macro definition for a given name.
-     *
-     * @param {string} name - Macro name (identifier).
-     * @returns {MacroDefinition|undefined}
-     */
-    getMacro(name) {
-        if (typeof name !== 'string' || !name.trim()) return undefined;
-        name = name.trim();
-        return this.#macros.get(name.toLowerCase());
-    }
-    /**
-     * Returns the primary (non-alias) definition for a macro.
-     * If given an alias name, returns the primary definition it points to.
-     *
-     * @param {string} name - Macro name or alias.
-     * @returns {MacroDefinition|undefined}
-     */
-    getPrimaryMacro(name) {
-        const def = this.getMacro(name);
-        if (!def) return undefined;
-        return def.aliasOf ? this.getMacro(def.aliasOf) : def;
-    }
-    /**
-     * Returns an array of all registered macros.
-     *
-     * @param {Object} [options] - Filter options.
-     * @param {boolean} [options.excludeAliases=false] - If true, excludes alias entries (only returns primary definitions).
-     * @param {boolean} [options.excludeHiddenAliases=false] - If true, excludes alias entries where visible=false.
-     * @returns {MacroDefinition[]}
-     */
-    getAllMacros({ excludeAliases = false, excludeHiddenAliases = false } = {}) {
-        let macros = Array.from(this.#macros.values());
-        if (excludeAliases) {
-            macros = macros.filter(m => !m.aliasOf);
-        } else if (excludeHiddenAliases) {
-            macros = macros.filter(m => !m.aliasOf || m.aliasVisible !== false);
-        }
-        return macros;
-    }
-    /**
-     * Executes a macro for a given call.
-     *
-     * @param {MacroCall} call - Macro call information.
-     * @param {Object} [options] - Additional options.
-     * @param {MacroDefinition} [options.defOverride] - Override the macro definition.
-     * @returns {string}
-     */
-    executeMacro(call, { defOverride } = {}) {
-        const name = call.name;
-        const def = defOverride || this.getMacro(name);
-        if (!def) {
-            throw new Error(`Macro "${name}" is not registered`);
-        }
-        const args = Array.isArray(call.args) ? call.args : [];
-        if (!isArgsValid(def, args)) {
-            const expectedMin = def.list ? def.minArgs + def.list.min : def.minArgs;
-            const expectedMax = def.list && def.list.max !== null
-                ? def.maxArgs + def.list.max
-                : (def.list ? null : def.maxArgs);
-            const expectation = (() => {
-                if (expectedMax !== null && expectedMax !== expectedMin) return `between ${expectedMin} and ${expectedMax}`;
-                if (expectedMax !== null && expectedMax === expectedMin) return `${expectedMin}`;
-                return `at least ${expectedMin}`;
-            })();
-            const message = `Macro "${def.name}" called with ${args.length} unnamed arguments but expects ${expectation}.`;
-            if (def.strictArgs) {
-                throw createMacroRuntimeError({ message, call, def });
-            }
-            logMacroRuntimeWarning({ message, call, def });
-        }
-        // Compute unnamed args (required + optional, up to maxArgs)
-        const unnamedArgsCount = Math.min(args.length, def.maxArgs);
-        const unnamedArgsValues = args.slice(0, unnamedArgsCount);
-        const listValues = !def.list ? null : args.length > def.maxArgs ? args.slice(def.maxArgs) : [];
-        // Perform best-effort type validation for documented positional arguments.
-        // This can throw an error if the arguments are invalid.
-        validateArgTypes(call, def, unnamedArgsValues);
-        const namedArgs = null;
-        /** @type {MacroExecutionContext} */
-        const executionContext = {
-            name: def.name,
-            args,
-            unnamedArgs: unnamedArgsValues,
-            list: listValues,
-            namedArgs,
-            flags: call.flags,
-            isScoped: call.isScoped,
-            raw: call.rawInner,
-            rawOriginal: call.rawWithBraces,
-            rawArgs: call.rawArgs,
-            env: call.env,
-            cstNode: call.cstNode,
-            range: call.range,
-            normalize: MacroEngine.normalizeMacroResult.bind(MacroEngine),
-            trimContent: MacroEngine.trimScopedContent.bind(MacroEngine),
-            resolve: (text) => MacroEngine.evaluate(text, call.env),
-        };
-        const result = def.handler(executionContext);
-        return executionContext.normalize(result);
+    }
+}

public/scripts/slash-commands/SlashCommandClosure.js+102 -0 Viewed

 import { substituteParams } from '../../script.js';
+import { power_user } from '../power-user.js';
 import { delay, escapeRegex, uuidv4 } from '../utils.js';
 import { SlashCommand } from './SlashCommand.js';
 import { SlashCommandAbortController } from './SlashCommandAbortController.js';

+    }
     /**
+     * Performs parameter substitution using the macro engine.
+     * @param {string} text Text to substitute
+     * @param {SlashCommandScope} scope Script scope
+     * @param {{key:string, value:string|SlashCommandClosure}[]} macroList Custom scope macros
+     * @returns {string|SlashCommandClosure|(string|SlashCommandClosure)[]} Substituted text or list of strings/closures
+     */
+    substituteWithMacroEngine(text, scope, macroList) {
+        /** @type {Record<string, import('./../macros/engine/MacroEnv.types.js').DynamicMacroValue>} */
+        const dynamicMacros = {
+            'pipe': () => scope.pipe,
+            'var': {
+                strictArgs: false,
+                list: { min: 1, max: 2 },
+                handler: (context) => {
+                    try {
+                        // NB: Legacy replacer halted the script execution on unknown variables
+                        return scope.getVariable(context.list[0], context.list[1]);
+                    } catch (error) {
+                        console.warn('{{var}} dynamic macro execution error:', error);
+                        return '';
+                    }
+                },
+            },
+        };
+        // Special marker to denote closures in the substituted text
+        const CLOSURE_BOUNDARY = '\uFFF0~CLOSURE~\uFFF0';
+        /** @type {Map<string, SlashCommandClosure>} */
+        const closures = new Map();
+        /** @type {Record<string, { args: string[], value: string|SlashCommandClosure }[]>} */
+        const customMacros = {};
+        for (const macro of macroList) {
+            const [name, ...rest] = macro.key.split('::');
+            if (!Object.hasOwn(customMacros, name)) {
+                customMacros[name] = [];
+            }
+            customMacros[name].push({ args: rest, value: macro.value });
+        }
+        for (const [macroName, macroArguments] of Object.entries(customMacros)) {
+            dynamicMacros[macroName] = {
+                strictArgs: false,
+                list: { min: 0, max: Number.MAX_SAFE_INTEGER },
+                handler: (context) => {
+                    // Sort to prefer exact matches over wildcard matches
+                    const sortedMacroArgs = macroArguments.toSorted((a, b) => {
+                        const aHasWildcard = a.args.includes('*');
+                        const bHasWildcard = b.args.includes('*');
+                        if (aHasWildcard && !bHasWildcard) return 1;
+                        if (!aHasWildcard && bHasWildcard) return -1;
+                        return 0;
+                    });
+                    const findMacroMatch = (/** @type {{args: string[]}} */ i) => {
+                        // Exact match
+                        if (i.args.length === context.list.length && i.args.every((arg, index) => arg === context.list[index])) {
+                            return true;
+                        }
+                        // Wildcard match - if any definition arg is '*', it matches any value at that position
+                        if (i.args.length === context.list.length) {
+                            return i.args.every((arg, index) => arg === '*' || arg === context.list[index]);
+                        }
+                        return false;
+                    };
+                    const replacer = sortedMacroArgs.find(findMacroMatch)?.value;
+                    if (replacer instanceof SlashCommandClosure) {
+                        replacer.abortController = this.abortController;
+                        replacer.breakController = this.breakController;
+                        replacer.scope.parent = this.scope;
+                        if (this.debugController && !replacer.debugController) {
+                            replacer.debugController = this.debugController;
+                        }
+                        const closureKey = uuidv4();
+                        closures.set(closureKey, replacer);
+                        return `${CLOSURE_BOUNDARY}${closureKey}${CLOSURE_BOUNDARY}`;
+                    }
+                    return String(replacer ?? '');
+                },
+            };
+        }
+        const substitutedText = substituteParams(text, { dynamicMacros });
+        // If any closures were inserted, split the text accordingly
+        if (closures.size > 0) {
+            const parts = substitutedText.split(CLOSURE_BOUNDARY).map(part => closures.has(part) ? closures.get(part) : part).filter(Boolean);
+            return parts.length === 1 ? parts[0] : parts;
+        }
+        // No closures, return substituted text as-is
+        return substitutedText;
+    }
+    /**
+     *
      * @param {string} text
      * @param {SlashCommandScope} scope

             if (a.key.includes('*') && b.key.includes('*')) return b.key.indexOf('*') - a.key.indexOf('*');
             return 0;
         });
+        if (power_user.experimental_macro_engine) {
+            return this.substituteWithMacroEngine(text, scope, macroList);
+        }
         const macros = macroList.map(it=>escapeMacro(it)).join('|');
         const re = new RegExp(`(?<pipe>{{pipe}})|(?:{{var::(?<var>[^\\s]+?)(?:::(?<varIndex>(?!}}).+))?}})|(?:{{(?<macro>${macros})}})`);
         let done = '';

public/scripts/slash-commands/SlashCommandParser.js+4 -0 Viewed

+    }
     replaceGetvar(value) {
+        // Not needed with the new parser.
+        if (power_user.experimental_macro_engine) {
+            return value;
+        }
         return value.replace(/{{(get(?:global)?var)::([^}]+)}}/gi, (match, cmd, name, idx) => {
             name = name.trim();
             cmd = cmd.toLowerCase();

tests/frontend/MacroEngine.e2e.js+465 -10 Viewed

     });
     test.describe('Dynamic macros', () => {
-        test('should not resolve dynamic macro when called with arguments due to strict arity', async ({ page }) => {
+        test.describe('String value dynamic macros', () => {
-            /** @type {string[]} */
+            test('should resolve dynamic macro with string value', async ({ 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');
+                    const rawEnv = {
+                        content: 'Test: {{myvalue}}',
+                        dynamicMacros: {
+                            myvalue: 'hello world',
+                        },
+                    };
+                    const env = MacroEnvBuilder.buildFromRawEnv(rawEnv);
+                    return MacroEngine.evaluate('Test: {{myvalue}}', env);
+                });
+                expect(output).toBe('Test: hello world');
+            });
+            test('should resolve dynamic macro with numeric value converted to string', async ({ 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');
+                    const rawEnv = {
+                        content: '',
+                        dynamicMacros: {
+                            num: 42,
+                        },
+                    };
+                    const env = MacroEnvBuilder.buildFromRawEnv(rawEnv);
+                    return MacroEngine.evaluate('Value: {{num}}', env);
+                });
+                expect(output).toBe('Value: 42');
+            });
+            test('should not resolve string dynamic macro when called with arguments', async ({ page }) => {
                 const warnings = [];
                 page.on('console', msg => {
-                if (msg.type() === 'warning') {
+                    if (msg.type() === 'warning') warnings.push(msg.text());
-                    warnings.push(msg.text());
+                });
-                }
+                const input = 'Dyn: {{myvalue::extra}}';
+                const output = await page.evaluate(async (input) => {
+                    /** @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 rawEnv = {
+                        content: input,
+                        dynamicMacros: { myvalue: 'hello' },
+                    };
+                    const env = MacroEnvBuilder.buildFromRawEnv(rawEnv);
+                    return MacroEngine.evaluate(input, env);
+                }, input);
+                expect(output).toBe(input);
+                expect(warnings.some(w => w.includes('Macro "myvalue"') && w.includes('unnamed arguments'))).toBeTruthy();
+            });
+        });
+        test.describe('Handler function dynamic macros', () => {
+            test('should resolve dynamic macro with handler function', async ({ 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');
+                    const rawEnv = {
+                        content: '',
+                        dynamicMacros: {
+                            dyn: () => 'handler result',
+                        },
+                    };
+                    const env = MacroEnvBuilder.buildFromRawEnv(rawEnv);
+                    return MacroEngine.evaluate('Result: {{dyn}}', env);
+                });
+                expect(output).toBe('Result: handler result');
+            });
+            test('should pass execution context to handler function', async ({ 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');
+                    const rawEnv = {
+                        content: 'full content here',
+                        dynamicMacros: {
+                            dyn: (ctx) => `name=${ctx.name}, content=${ctx.env.content}`,
+                        },
+                    };
+                    const env = MacroEnvBuilder.buildFromRawEnv(rawEnv);
+                    return MacroEngine.evaluate('{{dyn}}', env);
+                });
+                expect(output).toBe('name=dyn, content=full content here');
+            });
+            test('should not resolve handler dynamic macro when called with arguments due to strict arity', async ({ page }) => {
+                const warnings = [];
+                page.on('console', msg => {
+                    if (msg.type() === 'warning') warnings.push(msg.text());
                 });
                 const input = 'Dyn: {{dyn::extra}}';

                     /** @type {import('../../public/scripts/macros/engine/MacroEnvBuilder.js')} */
                     const { MacroEnvBuilder } = await import('./scripts/macros/engine/MacroEnvBuilder.js');
-                /** @type {import('../../public/scripts/macros/engine/MacroEnvBuilder.js').MacroEnvRawContext} */
                     const rawEnv = {
                         content: input,
                         dynamicMacros: {

                         },
                     };
                     const env = MacroEnvBuilder.buildFromRawEnv(rawEnv);
+                    return MacroEngine.evaluate(input, env);
+                }, input);
+                expect(output).toBe(input);
+                expect(warnings.some(w => w.includes('Macro "dyn"') && w.includes('unnamed arguments'))).toBeTruthy();
+            });
+        });
+        test.describe('MacroDefinitionOptions dynamic macros', () => {
+            test('should resolve dynamic macro with MacroDefinitionOptions', async ({ 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');
+                    const rawEnv = {
+                        content: '',
+                        dynamicMacros: {
+                            greet: {
+                                description: 'A greeting macro',
+                                handler: () => 'Hello from options!',
+                            },
+                        },
+                    };
+                    const env = MacroEnvBuilder.buildFromRawEnv(rawEnv);
+                    return MacroEngine.evaluate('{{greet}}', env);
+                });
+                expect(output).toBe('Hello from options!');
+            });
+            test('should support unnamed arguments in dynamic macro with options', async ({ 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');
+                    const rawEnv = {
+                        content: '',
+                        dynamicMacros: {
+                            greet: {
+                                unnamedArgs: [{ name: 'name' }],
+                                handler: ({ unnamedArgs: [name] }) => `Hello, ${name}!`,
+                            },
+                        },
+                    };
+                    const env = MacroEnvBuilder.buildFromRawEnv(rawEnv);
+                    return MacroEngine.evaluate('{{greet::World}}', env);
+                });
+                expect(output).toBe('Hello, World!');
+            });
+            test('should support multiple unnamed arguments in dynamic macro', async ({ 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');
+                    const rawEnv = {
+                        content: '',
+                        dynamicMacros: {
+                            wrap: {
+                                unnamedArgs: [
+                                    { name: 'content' },
+                                    { name: 'prefix' },
+                                    { name: 'suffix' },
+                                ],
+                                handler: ({ unnamedArgs: [content, prefix, suffix] }) => `${prefix}${content}${suffix}`,
+                            },
+                        },
+                    };
+                    const env = MacroEnvBuilder.buildFromRawEnv(rawEnv);
+                    return MacroEngine.evaluate('{{wrap::hello::[::]}}', env);
+                });
+                expect(output).toBe('[hello]');
+            });
+            test('should support optional arguments in dynamic macro', async ({ 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');
+                    const rawEnv = {
+                        content: '',
+                        dynamicMacros: {
+                            greet: {
+                                unnamedArgs: [
+                                    { name: 'name' },
+                                    { name: 'greeting', optional: true, defaultValue: 'Hello' },
+                                ],
+                                handler: ({ unnamedArgs: [name, greeting] }) => `${greeting || 'Hello'}, ${name}!`,
+                            },
+                        },
+                    };
+                    const env = MacroEnvBuilder.buildFromRawEnv(rawEnv);
+                    const result1 = MacroEngine.evaluate('{{greet::World}}', env);
+                    const result2 = MacroEngine.evaluate('{{greet::World::Hi}}', env);
+                    return { result1, result2 };
+                });
+                expect(output.result1).toBe('Hello, World!');
+                expect(output.result2).toBe('Hi, World!');
+            });
+            test('should support list arguments in dynamic macro', async ({ 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');
+                    const rawEnv = {
+                        content: '',
+                        dynamicMacros: {
+                            join: {
+                                unnamedArgs: [{ name: 'separator' }],
+                                list: true,
+                                handler: ({ unnamedArgs: [sep], list }) => list.join(sep),
+                            },
+                        },
+                    };
+                    const env = MacroEnvBuilder.buildFromRawEnv(rawEnv);
+                    return MacroEngine.evaluate('{{join::-::a::b::c}}', env);
+                });
+                expect(output).toBe('a-b-c');
+            });
+            test('should enforce type validation in dynamic macro with options', async ({ page }) => {
+                const warnings = [];
+                page.on('console', msg => {
+                    if (msg.type() === 'warning') warnings.push(msg.text());
+                });
+                const input = '{{calc::abc}}';
+                const output = await page.evaluate(async (input) => {
+                    /** @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 rawEnv = {
+                        content: input,
+                        dynamicMacros: {
+                            calc: {
+                                unnamedArgs: [{ name: 'value', type: 'integer' }],
+                                strictArgs: true,
+                                handler: ({ unnamedArgs: [val] }) => `#${val}#`,
+                            },
+                        },
+                    };
+                    const env = MacroEnvBuilder.buildFromRawEnv(rawEnv);
                     return MacroEngine.evaluate(input, env);
                 }, input);
-            // Dynamic macro with arguments should not resolve because the
-            // temporary definition is strictArgs: true and minArgs/maxArgs: 0.
                 expect(output).toBe(input);
+                expect(warnings.some(w => w.includes('calc') && w.includes('expected type integer'))).toBeTruthy();
+            });
-            // A runtime arity warning for the dynamic macro should be logged
+            test('should respect strictArgs: false in dynamic macro with options', async ({ page }) => {
-            expect(warnings.some(w => w.includes('Macro "dyn"') && w.includes('unnamed arguments'))).toBeTruthy();
+                const warnings = [];
+                page.on('console', msg => {
+                    if (msg.type() === 'warning') warnings.push(msg.text());
+                });
+                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');
+                    const rawEnv = {
+                        content: '',
+                        dynamicMacros: {
+                            calc: {
+                                unnamedArgs: [{ name: 'value', type: 'integer' }],
+                                strictArgs: false,
+                                handler: ({ unnamedArgs: [val] }) => `#${val}#`,
+                            },
+                        },
+                    };
+                    const env = MacroEnvBuilder.buildFromRawEnv(rawEnv);
+                    return MacroEngine.evaluate('{{calc::abc}}', env);
+                });
+                expect(output).toBe('#abc#');
+                expect(warnings.some(w => w.includes('calc') && w.includes('expected type integer'))).toBeTruthy();
+            });
+            test('should fail arity check in dynamic macro with options when too few args', async ({ page }) => {
+                const warnings = [];
+                page.on('console', msg => {
+                    if (msg.type() === 'warning') warnings.push(msg.text());
+                });
+                const input = '{{greet}}';
+                const output = await page.evaluate(async (input) => {
+                    /** @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 rawEnv = {
+                        content: input,
+                        dynamicMacros: {
+                            greet: {
+                                unnamedArgs: [{ name: 'name' }],
+                                handler: ({ unnamedArgs: [name] }) => `Hello, ${name}!`,
+                            },
+                        },
+                    };
+                    const env = MacroEnvBuilder.buildFromRawEnv(rawEnv);
+                    return MacroEngine.evaluate(input, env);
+                }, input);
+                expect(output).toBe(input);
+                expect(warnings.some(w => w.includes('greet') && w.includes('unnamed arguments'))).toBeTruthy();
+            });
+            test('should fail arity check in dynamic macro with options when too many args', async ({ page }) => {
+                const warnings = [];
+                page.on('console', msg => {
+                    if (msg.type() === 'warning') warnings.push(msg.text());
+                });
+                const input = '{{greet::one::two}}';
+                const output = await page.evaluate(async (input) => {
+                    /** @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 rawEnv = {
+                        content: input,
+                        dynamicMacros: {
+                            greet: {
+                                unnamedArgs: [{ name: 'name' }],
+                                handler: ({ unnamedArgs: [name] }) => `Hello, ${name}!`,
+                            },
+                        },
+                    };
+                    const env = MacroEnvBuilder.buildFromRawEnv(rawEnv);
+                    return MacroEngine.evaluate(input, env);
+                }, input);
+                expect(output).toBe(input);
+                expect(warnings.some(w => w.includes('greet') && w.includes('unnamed arguments'))).toBeTruthy();
+            });
+            test('should handle invalid MacroDefinitionOptions gracefully', async ({ page }) => {
+                const warnings = [];
+                page.on('console', msg => {
+                    if (msg.type() === 'warning') warnings.push(msg.text());
+                });
+                const input = '{{bad}}';
+                const output = await page.evaluate(async (input) => {
+                    /** @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');
+                    /** @type {import('../../public/scripts/macros/engine/MacroEnvBuilder.js').MacroEnvRawContext} */
+                    const rawEnv = {
+                        content: input,
+                        dynamicMacros: {
+                            bad: {
+                                // Missing handler - should fail validation
+                                unnamedArgs: 1,
+                            },
+                        },
+                    };
+                    const env = MacroEnvBuilder.buildFromRawEnv(rawEnv);
+                    return MacroEngine.evaluate(input, env);
+                }, input);
+                // Should remain unresolved since options are invalid
+                expect(output).toBe(input);
+                expect(warnings.some(w => w.includes('bad') && w.includes('is not defined correctly'))).toBeTruthy();
+            });
+        });
+        test.describe('Dynamic macro priority and case sensitivity', () => {
+            test('should override registered macro with dynamic macro of same name', async ({ 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');
+                    const rawEnv = {
+                        content: '',
+                        name1Override: 'User',
+                        dynamicMacros: {
+                            user: 'DynamicUser',
+                        },
+                    };
+                    const env = MacroEnvBuilder.buildFromRawEnv(rawEnv);
+                    return MacroEngine.evaluate('{{user}}', env);
+                });
+                expect(output).toBe('DynamicUser');
+            });
+            test('should match dynamic macro names case-insensitively', async ({ 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');
+                    const rawEnv = {
+                        content: '',
+                        dynamicMacros: {
+                            MyMacro: 'value',
+                        },
+                    };
+                    const env = MacroEnvBuilder.buildFromRawEnv(rawEnv);
+                    const r1 = MacroEngine.evaluate('{{MyMacro}}', env);
+                    const r2 = MacroEngine.evaluate('{{mymacro}}', env);
+                    const r3 = MacroEngine.evaluate('{{MYMACRO}}', env);
+                    return { r1, r2, r3 };
+                });
+                expect(output.r1).toBe('value');
+                expect(output.r2).toBe('value');
+                expect(output.r3).toBe('value');
+            });
+            test('should resolve multiple different dynamic macros in same evaluation', async ({ 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');
+                    const rawEnv = {
+                        content: '',
+                        dynamicMacros: {
+                            a: 'alpha',
+                            b: () => 'beta',
+                            c: {
+                                handler: () => 'gamma',
+                            },
+                        },
+                    };
+                    const env = MacroEnvBuilder.buildFromRawEnv(rawEnv);
+                    return MacroEngine.evaluate('{{a}}-{{b}}-{{c}}', env);
+                });
+                expect(output).toBe('alpha-beta-gamma');
+            });
         });
     });

tests/frontend/MacroEnvBuilder.e2e.js+188 -3 Viewed

         });
     });
+    test.describe('Dynamic macros in env', () => {
         test('merges dynamicMacros properties into env.dynamicMacros', async ({ page }) => {
             const dynamicMacros = await page.evaluate(async () => {
                 /** @type {import('../../public/scripts/macros/engine/MacroEnvBuilder.js')} */
                 const { MacroEnvBuilder } = await import('./scripts/macros/engine/MacroEnvBuilder.js');
-            /** @type {import('../../public/scripts/macros/engine/MacroEnvBuilder.js').MacroEnvRawContext} */
                 const ctx = {
                     content: '',
                     dynamicMacros: {
                         simple: 'value',
                         number: 42,
-                    nested: { foo: 'bar' },
                     },
                 };

             expect(dynamicMacros.simple).toBe('value');
             expect(dynamicMacros.number).toBe(42);
-        expect(dynamicMacros.nested).toEqual({ foo: 'bar' });
+        });
+        test('normalizes dynamic macro keys to lowercase', async ({ page }) => {
+            const result = await page.evaluate(async () => {
+                /** @type {import('../../public/scripts/macros/engine/MacroEnvBuilder.js')} */
+                const { MacroEnvBuilder } = await import('./scripts/macros/engine/MacroEnvBuilder.js');
+                const ctx = {
+                    content: '',
+                    dynamicMacros: {
+                        MyMacro: 'value1',
+                        UPPERCASE: 'value2',
+                        lowercase: 'value3',
+                    },
+                };
+                const env = MacroEnvBuilder.buildFromRawEnv(ctx);
+                return {
+                    hasLower: 'mymacro' in env.dynamicMacros,
+                    hasUpper: 'uppercase' in env.dynamicMacros,
+                    hasLowercase: 'lowercase' in env.dynamicMacros,
+                    value1: env.dynamicMacros['mymacro'],
+                    value2: env.dynamicMacros['uppercase'],
+                    value3: env.dynamicMacros['lowercase'],
+                };
+            });
+            expect(result.hasLower).toBe(true);
+            expect(result.hasUpper).toBe(true);
+            expect(result.hasLowercase).toBe(true);
+            expect(result.value1).toBe('value1');
+            expect(result.value2).toBe('value2');
+            expect(result.value3).toBe('value3');
+        });
+        test('accepts string values for dynamic macros', async ({ page }) => {
+            const result = await page.evaluate(async () => {
+                /** @type {import('../../public/scripts/macros/engine/MacroEnvBuilder.js')} */
+                const { MacroEnvBuilder } = await import('./scripts/macros/engine/MacroEnvBuilder.js');
+                const ctx = {
+                    content: '',
+                    dynamicMacros: {
+                        greeting: 'Hello, World!',
+                    },
+                };
+                const env = MacroEnvBuilder.buildFromRawEnv(ctx);
+                return {
+                    value: env.dynamicMacros['greeting'],
+                    type: typeof env.dynamicMacros['greeting'],
+                };
+            });
+            expect(result.value).toBe('Hello, World!');
+            expect(result.type).toBe('string');
+        });
+        test('accepts handler functions for dynamic macros', async ({ page }) => {
+            const result = await page.evaluate(async () => {
+                /** @type {import('../../public/scripts/macros/engine/MacroEnvBuilder.js')} */
+                const { MacroEnvBuilder } = await import('./scripts/macros/engine/MacroEnvBuilder.js');
+                const ctx = {
+                    content: '',
+                    dynamicMacros: {
+                        dyn: () => 'handler result',
+                    },
+                };
+                const env = MacroEnvBuilder.buildFromRawEnv(ctx);
+                const storedValue = env.dynamicMacros['dyn'];
+                return {
+                    isFunction: typeof storedValue === 'function',
+                    callResult: typeof storedValue === 'function' ? storedValue() : null,
+                };
+            });
+            expect(result.isFunction).toBe(true);
+            expect(result.callResult).toBe('handler result');
+        });
+        test('accepts MacroDefinitionOptions objects for dynamic macros', async ({ page }) => {
+            const result = await page.evaluate(async () => {
+                /** @type {import('../../public/scripts/macros/engine/MacroEnvBuilder.js')} */
+                const { MacroEnvBuilder } = await import('./scripts/macros/engine/MacroEnvBuilder.js');
+                const ctx = {
+                    content: '',
+                    dynamicMacros: {
+                        greet: {
+                            description: 'A greeting macro',
+                            unnamedArgs: [{ name: 'name' }],
+                            handler: ({ unnamedArgs: [name] }) => `Hello, ${name}!`,
+                        },
+                    },
+                };
+                const env = MacroEnvBuilder.buildFromRawEnv(ctx);
+                const storedValue = env.dynamicMacros['greet'];
+                return {
+                    isObject: typeof storedValue === 'object' && storedValue !== null,
+                    hasHandler: typeof storedValue?.handler === 'function',
+                    hasDescription: typeof storedValue?.description === 'string',
+                    hasUnnamedArgs: Array.isArray(storedValue?.unnamedArgs),
+                };
+            });
+            expect(result.isObject).toBe(true);
+            expect(result.hasHandler).toBe(true);
+            expect(result.hasDescription).toBe(true);
+            expect(result.hasUnnamedArgs).toBe(true);
+        });
+        test('supports mixed dynamic macro value types', async ({ page }) => {
+            const result = await page.evaluate(async () => {
+                /** @type {import('../../public/scripts/macros/engine/MacroEnvBuilder.js')} */
+                const { MacroEnvBuilder } = await import('./scripts/macros/engine/MacroEnvBuilder.js');
+                const ctx = {
+                    content: '',
+                    dynamicMacros: {
+                        stringVal: 'direct string',
+                        funcVal: () => 'from function',
+                        optionsVal: {
+                            handler: () => 'from options',
+                            unnamedArgs: 1,
+                        },
+                    },
+                };
+                const env = MacroEnvBuilder.buildFromRawEnv(ctx);
+                return {
+                    stringType: typeof env.dynamicMacros['stringval'],
+                    funcType: typeof env.dynamicMacros['funcval'],
+                    optionsType: typeof env.dynamicMacros['optionsval'],
+                    optionsHasHandler: typeof env.dynamicMacros['optionsval']?.handler === 'function',
+                };
+            });
+            expect(result.stringType).toBe('string');
+            expect(result.funcType).toBe('function');
+            expect(result.optionsType).toBe('object');
+            expect(result.optionsHasHandler).toBe(true);
+        });
+        test('handles null dynamicMacros gracefully', async ({ page }) => {
+            const result = await page.evaluate(async () => {
+                /** @type {import('../../public/scripts/macros/engine/MacroEnvBuilder.js')} */
+                const { MacroEnvBuilder } = await import('./scripts/macros/engine/MacroEnvBuilder.js');
+                const ctx = {
+                    content: '',
+                    dynamicMacros: null,
+                };
+                const env = MacroEnvBuilder.buildFromRawEnv(ctx);
+                return {
+                    hasDynamicMacros: 'dynamicMacros' in env,
+                    isEmpty: Object.keys(env.dynamicMacros).length === 0,
+                };
+            });
+            expect(result.hasDynamicMacros).toBe(true);
+            expect(result.isEmpty).toBe(true);
+        });
+        test('handles undefined dynamicMacros gracefully', async ({ page }) => {
+            const result = await page.evaluate(async () => {
+                /** @type {import('../../public/scripts/macros/engine/MacroEnvBuilder.js')} */
+                const { MacroEnvBuilder } = await import('./scripts/macros/engine/MacroEnvBuilder.js');
+                const ctx = {
+                    content: '',
+                    // dynamicMacros not provided
+                };
+                const env = MacroEnvBuilder.buildFromRawEnv(ctx);
+                return {
+                    hasDynamicMacros: 'dynamicMacros' in env,
+                    isEmpty: Object.keys(env.dynamicMacros).length === 0,
+                };
+            });
+            expect(result.hasDynamicMacros).toBe(true);
+            expect(result.isEmpty).toBe(true);
+        });
     });
     test('sets system.model field from getGeneratingModel helper', async ({ page }) => {

tests/frontend/MacroSlashCommands.e2e.js+177 -0 Viewed

+import { test, expect } from '@playwright/test';
+import { testSetup } from './frontent-test-utils.js';
+test.describe('MacroSlashCommands', () => {
+    test.beforeEach(testSetup.awaitST);
+    test.describe('Parser Flags', () => {
+        test('should bypass REPLACE_GETVAR', async ({ page }) => {
+            const output = await page.evaluate(async () => {
+                const { executeSlashCommandsWithOptions } = await import('./scripts/slash-commands.js');
+                const { power_user } = await import('./scripts/power-user.js');
+                power_user.experimental_macro_engine = true;
+                return (await executeSlashCommandsWithOptions('/parser-flag REPLACE_GETVAR || /setvar key=x \\{\\{lastMessageId}} || /pass {{getvar::x}}')).pipe;
+            });
+            expect(output).toBe('{{lastMessageId}}');
+        });
+    });
+    test.describe('{{pipe}} Macro', () => {
+        test('should support {{pipe}} macro', async ({ page }) => {
+            const output = await page.evaluate(async () => {
+                const { executeSlashCommandsWithOptions } = await import('./scripts/slash-commands.js');
+                const { power_user } = await import('./scripts/power-user.js');
+                power_user.experimental_macro_engine = true;
+                return (await executeSlashCommandsWithOptions('/pass Hello World || /pass {{pipe}}')).pipe;
+            });
+            expect(output).toBe('Hello World');
+        });
+    });
+    test.describe('{{var}} Macro', () => {
+        test('should support {{var::key}} macro', async ({ page }) => {
+            const output = await page.evaluate(async () => {
+                const { executeSlashCommandsWithOptions } = await import('./scripts/slash-commands.js');
+                const { power_user } = await import('./scripts/power-user.js');
+                power_user.experimental_macro_engine = true;
+                return (await executeSlashCommandsWithOptions('/let key=greeting Hello || /pass {{var::greeting}}')).pipe;
+            });
+            expect(output).toBe('Hello');
+        });
+        test('should support {{var::key::index}} macro', async ({ page }) => {
+            const output = await page.evaluate(async () => {
+                const { executeSlashCommandsWithOptions } = await import('./scripts/slash-commands.js');
+                const { power_user } = await import('./scripts/power-user.js');
+                power_user.experimental_macro_engine = true;
+                return (await executeSlashCommandsWithOptions('/let key=list ["item1","item2","item3"] || /pass {{var::list::1}}')).pipe;
+            });
+            expect(output).toBe('item2');
+        });
+        test('should not fail on unknown variable keys', async ({ page }) => {
+            const output = await page.evaluate(async () => {
+                const { executeSlashCommandsWithOptions } = await import('./scripts/slash-commands.js');
+                const { power_user } = await import('./scripts/power-user.js');
+                power_user.experimental_macro_engine = true;
+                return (await executeSlashCommandsWithOptions('/pass {{var::unknownKey}}')).pipe;
+            });
+            expect(output).toBe('');
+        });
+        test('should not fail on out-of-bounds variable index', async ({ page }) => {
+            const output = await page.evaluate(async () => {
+                const { executeSlashCommandsWithOptions } = await import('./scripts/slash-commands.js');
+                const { power_user } = await import('./scripts/power-user.js');
+                power_user.experimental_macro_engine = true;
+                return (await executeSlashCommandsWithOptions('/let key=test {"key":"value"} || /pass {{var::test::error}}')).pipe;
+            });
+            expect(output).toBe('');
+        });
+    });
+    test.describe('{{arg}} Macro', () => {
+        test('should support {{arg}} macro with plain value', async ({ page }) => {
+            const output = await page.evaluate(async () => {
+                const { executeSlashCommandsWithOptions } = await import('./scripts/slash-commands.js');
+                const { power_user } = await import('./scripts/power-user.js');
+                power_user.experimental_macro_engine = true;
+                return (await executeSlashCommandsWithOptions('/qr-arg hello world || /pass {{arg::hello}}')).pipe;
+            });
+            expect(output).toBe('world');
+        });
+        test('should support {{arg}} macro with closure value', async ({ page }) => {
+            const output = await page.evaluate(async () => {
+                const { executeSlashCommandsWithOptions } = await import('./scripts/slash-commands.js');
+                const { power_user } = await import('./scripts/power-user.js');
+                power_user.experimental_macro_engine = true;
+                return (await executeSlashCommandsWithOptions('/qr-arg x {: /echo test :} || /echo {{arg::x}}')).pipe;
+            });
+            expect(output).toBe('[Closure]');
+        });
+        test('should support mixed type {{arg}} macro values', async ({ page }) => {
+            const output = await page.evaluate(async () => {
+                const { executeSlashCommandsWithOptions } = await import('./scripts/slash-commands.js');
+                const { power_user } = await import('./scripts/power-user.js');
+                power_user.experimental_macro_engine = true;
+                return (await executeSlashCommandsWithOptions('/qr-arg a simple || /qr-arg b {: /echo closure :} || /echo {{arg::a}} and {{arg::b}}')).pipe;
+            });
+            expect(output).toBe('simple and ,[Closure]');
+        });
+        test('should support wildcard {{arg}} macro', async ({ page }) => {
+            const output = await page.evaluate(async () => {
+                const { executeSlashCommandsWithOptions } = await import('./scripts/slash-commands.js');
+                const { power_user } = await import('./scripts/power-user.js');
+                power_user.experimental_macro_engine = true;
+                return (await executeSlashCommandsWithOptions('/qr-arg * wildcard || /pass {{arg::any}}')).pipe;
+            });
+            expect(output).toBe('wildcard');
+        });
+    });
+    test.describe('Custom Scope Macros', () => {
+        test('should support {{timesIndex}} in /times command', async ({ page }) => {
+            const output = await page.evaluate(async () => {
+                const { executeSlashCommandsWithOptions } = await import('./scripts/slash-commands.js');
+                const { power_user } = await import('./scripts/power-user.js');
+                power_user.experimental_macro_engine = true;
+                return (await executeSlashCommandsWithOptions('/times 1 {: /pass {{timesIndex}} :}')).pipe;
+            });
+            expect(output).toBe('0');
+        });
+        test('should support custom SlashCommandScope macros', async ({ page }) => {
+            const output = await page.evaluate(async () => {
+                const { executeSlashCommandsWithOptions } = await import('./scripts/slash-commands.js');
+                const { SlashCommandScope } = await import('./scripts/slash-commands/SlashCommandScope.js');
+                const { power_user } = await import('./scripts/power-user.js');
+                power_user.experimental_macro_engine = true;
+                // Create a custom scope with a macro
+                const customScope = new SlashCommandScope(null);
+                customScope.setMacro('uno::dos::tres', 'CUSTOM_VALUE');
+                customScope.setMacro('uno::dos::quatro', 'SHOULD_NOT_BE_USED');
+                customScope.setMacro('uno::dos::*', 'WILDCARD_VALUE');
+                return (await executeSlashCommandsWithOptions('/pass {{uno::dos::tres}}', { scope: customScope })).pipe;
+            });
+            expect(output).toBe('CUSTOM_VALUE');
+        });
+    });
+});