Macros 2.0 (v0.7.0) -Variable Shorthand: New Operators & Lazy Evaluation (#4997) * Add new variable shorthand operators and new variable macros - Add `{{hasvar}}` and `{{deletevar}}` macros for local variables - Add `{{hasglobalvar}}` and `{{deleteglobalvar}}` macros for global variables - Implement new variable shorthand operators: `-=`, `||`, `??`, `||=`, `??=`, `==` - Refactor variable expression evaluation to use direct variable API calls instead of routing through macro registry - Add comprehensive operator support in lexer with proper token ordering for multi-character operators * Implement lazy evaluation for variable shorthand value expressions - Replace eager value evaluation with lazy evaluation pattern for variable operators - Add `#createLazyValue()` method that caches value expression result on first call - Change `#executeVariableOperation()` to accept `lazyValue` function instead of pre-evaluated value - Only evaluate value expressions when actually needed (e.g., when variable is falsy for `||`, when variable doesn't exist for `??`) - Add comprehensive e2e tests * Update variable shorthand autocomplete with new operators and add edge case tests - Add new operators to autocomplete definitions: `-=`, `||`, `??`, `||=`, `??=`, `==` - Update example lists in `VariableShorthandAutoCompleteOption` and `VariableNameAutoCompleteOption` - Add operator definitions with descriptions and `needsValue` flags to `VariableOperatorDefinitions` - Update `parseMacroContext()` to recognize new operators with proper ordering (longer operators checked first) * Add not equals (!=) operator to variable shorthand expressions - Add `!=` operator to variable shorthand definitions for local and global variables - Implement `notEquals` operation in `MacroCstWalker` that returns inverted equality comparison - Add `NotEquals` token to lexer with pattern `/!=` - Update parser to handle `!=` operator with value expression - Add `!=` operator to autocomplete examples and operator definitions - Update `parseMacroContext()` to recognize `!=` operator and... * Tiny code review fixes - Fix typo: "insie" → "inside" in variable shorthand operators comment - Remove extra space in `{{getglobalvar}}` example usage * Fix missing closing braces in hasglobalvar macro example usage * Fix isFalsy to normalize value before checking boolean state in variable shorthand operators - Apply `normalize()` to value before passing to `isFalseBoolean()` in `isFalsy` helper - Ensures consistent falsy evaluation for variable shorthand operators like `||`, `??`, `||=`, `??=` * Fix pipe character inside macro braces being treated as command separator - Add `isInsideMacroBraces()` method to track unclosed `{{}}` macro braces - Modify `testCommandEnd()` to only treat `|` as command end when not inside macro braces - Scan text behind current position to calculate macro brace depth - Skip second character when detecting `{{` or `}}` pairs - Ensure `depth` never goes below 0 using `Math.max(0, depth - 1)` * Add aliases for variable existence and deletion macros - Add `varexists` alias for `hasvar` macro - Add `flushvar` alias for `deletevar` macro - Add `globalvarexists` alias for `hasglobalvar` macro - Add `flushglobalvar` alias for `deleteglobalvar` macro * Update variable shorthand operator descriptions to clarify return behavior - Add "returns nothing" clarification to `=`, `+=`, `-=` operators in examples and definitions - Add "returns the new value" clarification to `++`, `--` operators in examples and definitions - Update `VariableOperatorDefinitions` descriptions to match example text - Ensures users understand which operators return values vs perform silent mutations

f8c373f55a8cdcba93c43d8a88b760ecb76ac600

Wolfsblvt <wolfsblvt@gmail.com>

Signed

Parents: 9e88f2338231c06ce62eeca3dc98dafcab803eca

public/scripts/autocomplete/EnhancedMacroAutoCompleteOption.js+98 -16 Viewed

         type: VariableShorthandType.LOCAL,
         name: 'Local Variable',
         description: 'Access or modify a local variable (scoped to current chat).',
-        operations: ['get', 'set (=)', 'increment (++)', 'decrement (--)', 'add (+=)'],
+        operations: ['get', 'set (=)', 'increment (++)', 'decrement (--)', 'add (+=)', 'subtract (-=)', 'logical or (||)', 'nullish coalescing (??)', 'logical or assign (||=)', 'nullish coalescing assign (??=)', 'equals (==)', 'not equals (!=)'],
     }],
     [VariableShorthandType.GLOBAL, {
         type: VariableShorthandType.GLOBAL,
         name: 'Global Variable',
         description: 'Access or modify a global variable (shared across all chats).',
-        operations: ['get', 'set (=)', 'increment (++)', 'decrement (--)', 'add (+=)'],
+        operations: ['get', 'set (=)', 'increment (++)', 'decrement (--)', 'add (+=)', 'subtract (-=)', 'logical or (||)', 'nullish coalescing (??)', 'logical or assign (||=)', 'nullish coalescing assign (??=)', 'equals (==)', 'not equals (!=)'],
     }],
 ]);

         const prefix = this.#varDef.type;
         const examples = [
             `{{${prefix}myvar}} - Get variable value`,
-            `{{${prefix}myvar = value}} - Set variable`,
+            `{{${prefix}myvar = value}} - Set variable (returns nothing)`,
-            `{{${prefix}counter++}} - Increment`,
+            `{{${prefix}counter++}} - Increment and get value`,
-            `{{${prefix}counter--}} - Decrement`,
+            `{{${prefix}counter--}} - Decrement and get value`,
-            `{{${prefix}myvar += text}} - Append/add`,
+            `{{${prefix}myvar += text}} - Append/add (returns nothing)`,
+            `{{${prefix}score -= 5}} - Subtract (returns nothing)`,
+            `{{${prefix}myvar || default}} - Get with fallback if falsy`,
+            `{{${prefix}myvar ?? default}} - Get with fallback if undefined`,
+            `{{${prefix}myvar ||= value}} - Set if falsy, get value`,
+            `{{${prefix}myvar ??= value}} - Set if undefined, get value`,
+            `{{${prefix}myvar == test}} - Compare (returns true/false)`,
+            `{{${prefix}myvar != test}} - Compare not equal (returns true/false)`,
         ];
         for (const ex of examples) {
             const li = document.createElement('li');

             `{{${prefix}${this.#varName}++}} - Increment`,
             `{{${prefix}${this.#varName}--}} - Decrement`,
             `{{${prefix}${this.#varName} += text}} - Append/add`,
+            `{{${prefix}${this.#varName} -= 5}} - Subtract`,
+            `{{${prefix}${this.#varName} || default}} - Get with fallback if falsy`,
+            `{{${prefix}${this.#varName} ?? default}} - Get with fallback if undefined`,
+            `{{${prefix}${this.#varName} ||= value}} - Set if falsy, get value`,
+            `{{${prefix}${this.#varName} ??= value}} - Set if undefined, get value`,
+            `{{${prefix}${this.#varName} == test}} - Compare (returns true/false)`,
+            `{{${prefix}${this.#varName} != test}} - Compare not equal (returns true/false)`,
         ];
         for (const ex of examples) {
             const li = document.createElement('li');

     ['=', {
         symbol: '=',
         name: 'Set',
-        description: 'Set the variable to a new value.',
+        description: 'Set the variable to a new value. Returns nothing.',
         needsValue: true,
     }],
     ['++', {
         symbol: '++',
         name: 'Increment',
-        description: 'Increment the variable by 1 (numeric).',
+        description: 'Increment the variable by 1 (numeric). Returns the new value.',
         needsValue: false,
     }],
     ['--', {
         symbol: '--',
         name: 'Decrement',
-        description: 'Decrement the variable by 1 (numeric).',
+        description: 'Decrement the variable by 1 (numeric). Returns the new value.',
         needsValue: false,
     }],
     ['+=', {
         symbol: '+=',
         name: 'Add',
-        description: 'Add to the variable (numeric addition or string concatenation).',
+        description: 'Add to the variable (numeric addition or string concatenation). Returns nothing.',
+        needsValue: true,
+    }],
+    ['-=', {
+        symbol: '-=',
+        name: 'Subtract',
+        description: 'Subtract a numeric value from the variable. Returns nothing.',
+        needsValue: true,
+    }],
+    ['||', {
+        symbol: '||',
+        name: 'Logical Or',
+        description: 'Return the fallback value if the variable is falsy, otherwise return the variable value.',
+        needsValue: true,
+    }],
+    ['??', {
+        symbol: '??',
+        name: 'Nullish Coalescing',
+        description: 'Return the fallback value only if the variable does not exist, otherwise return the variable value (even if falsy).',
+        needsValue: true,
+    }],
+    ['||=', {
+        symbol: '||=',
+        name: 'Logical Or Assign',
+        description: 'If the variable is falsy, set it to the value and return it; otherwise return the current value.',
+        needsValue: true,
+    }],
+    ['??=', {
+        symbol: '??=',
+        name: 'Nullish Coalescing Assign',
+        description: 'If the variable does not exist, set it to the value and return it; otherwise return the current value.',
+        needsValue: true,
+    }],
+    ['==', {
+        symbol: '==',
+        name: 'Equals',
+        description: 'Compare the variable value to another value. Returns "true" or "false".',
+        needsValue: true,
+    }],
+    ['!=', {
+        symbol: '!=',
+        name: 'Not Equals',
+        description: 'Compare the variable value to another value. Returns "true" if not equal, "false" if equal.',
         needsValue: true,
     }],
 ]);

             i++;
+        }
-        // Check for operators: ++, --, +=, =
+        // Check for operators: ++, --, +=, -=, ||=, ??=, ||, ??, ==, =
+        // Order matters: longer operators must be checked before shorter ones
         // Also track partial operator prefixes for autocomplete
         const operatorText = macroText.slice(i);
         let hasInvalidTrailingChars = false;

         } else if (operatorText.startsWith('--')) {
             variableOperator = '--';
             i += 2;
+        } else if (operatorText.startsWith('||=')) {
+            variableOperator = '||=';
+            i += 3;
+        } else if (operatorText.startsWith('??=')) {
+            variableOperator = '??=';
+            i += 3;
+        } else if (operatorText.startsWith('||')) {
+            variableOperator = '||';
+            i += 2;
+        } else if (operatorText.startsWith('??')) {
+            variableOperator = '??';
+            i += 2;
         } else if (operatorText.startsWith('+=')) {
             variableOperator = '+=';
             i += 2;
+        } else if (operatorText.startsWith('-=')) {
+            variableOperator = '-=';
+            i += 2;
+        } else if (operatorText.startsWith('==')) {
+            variableOperator = '==';
+            i += 2;
+        } else if (operatorText.startsWith('!=')) {
+            variableOperator = '!=';
+            i += 2;
         } else if (operatorText.startsWith('=')) {
             variableOperator = '=';
             i += 1;
-        } else if (operatorText.startsWith('+') || operatorText.startsWith('-')) {
+        } else if (operatorText.startsWith('+') || operatorText.startsWith('-') || operatorText.startsWith('|') || operatorText.startsWith('?') || operatorText.startsWith('!')) {
             // Partial operator prefix - user is typing an operator
             partialOperator = operatorText[0];
         } else if (operatorText.length > 0 && !/^\s/.test(operatorText)) {

             invalidTrailingChars = operatorText.trim();
+        }
-        // If operator requires a value (= or +=), parse the value
+        // Check if operator requires a value
-        if (variableOperator === '=' || variableOperator === '+=') {
+        const operatorDef = variableOperator ? VariableOperatorDefinitions.get(variableOperator) : null;
+        const operatorNeedsValue = operatorDef?.needsValue ?? false;
+        // If operator requires a value, parse the value
+        if (operatorNeedsValue) {
             // Skip whitespace after operator
             while (i < macroText.length && /\s/.test(macroText[i])) {
                 i++;

             isTypingVariableName = true;
         } else if (!variableOperator && !hasInvalidTrailingChars) {
             // Cursor is after variable name but no operator yet (and no invalid chars)
-            // This includes partial operator prefixes like '+' or '-'
+            // This includes partial operator prefixes like '+', '-', '|', '?'
             isTypingOperator = true;
-        } else if (variableOperator === '=' || variableOperator === '+=') {
+        } else if (operatorNeedsValue) {
             // Operator that requires value - cursor is in value area
             isTypingValue = true;
+        }

public/scripts/macros/definitions/variable-macros.js+86 -5 Viewed

         description: 'Increments a local variable by 1 and returns the new value. If the variable does not exist, it will be created.',
         returns: 'The new value of the local variable.',
         returnType: MacroValueType.NUMBER,
-        exampleUsage: ['{{incvar::myintvar}}'],
+        exampleUsage: ['{{incvar::myintvar}}', '{{incvar some-local-int-var}}'],
         handler: ({ unnamedArgs: [name], normalize }) => {
             const result = ctx.variables.local.inc(name);
             return normalize(result);

         description: 'Decrements a local variable by 1 and returns the new value. If the variable does not exist, it will be created.',
         returns: 'The new value of the local variable.',
         returnType: MacroValueType.NUMBER,
-        exampleUsage: ['{{decvar::myintvar}}'],
+        exampleUsage: ['{{decvar::myintvar}}', '{{decvar some-local-int-var}}'],
         handler: ({ unnamedArgs: [name], normalize }) => {
             const result = ctx.variables.local.dec(name);
             return normalize(result);

         description: 'Gets the value of a local variable.',
         returns: 'The value of the local variable.',
         returnType: [MacroValueType.STRING, MacroValueType.NUMBER],
-        exampleUsage: ['{{getvar::myvar}}', '{{getvar::myintvar}}'],
+        exampleUsage: ['{{getvar::myvar}}', '{{getvar myintvar}}'],
         handler: ({ unnamedArgs: [name], normalize }) => {
             const result = ctx.variables.local.get(name);
             return normalize(result);
         },
     });
+    // {{hasvar::name}} -> returns 'true' or 'false'
+    MacroRegistry.registerMacro('hasvar', {
+        aliases: [{ alias: 'varexists' }],
+        category: MacroCategory.VARIABLE,
+        unnamedArgs: [
+            {
+                name: 'name',
+                type: MacroValueType.STRING,
+                description: 'The name of the local variable to check.',
+            },
+        ],
+        description: 'Checks if a local variable exists.',
+        returns: '"true" if the variable exists, "false" otherwise.',
+        returnType: MacroValueType.STRING,
+        exampleUsage: ['{{hasvar::myvar}}', '{{hasvar some-local-var}}'],
+        handler: ({ unnamedArgs: [name] }) => {
+            return ctx.variables.local.has(name) ? 'true' : 'false';
+        },
+    });
+    // {{deletevar::name}} -> returns ''
+    MacroRegistry.registerMacro('deletevar', {
+        aliases: [{ alias: 'flushvar' }],
+        category: MacroCategory.VARIABLE,
+        unnamedArgs: [
+            {
+                name: 'name',
+                type: MacroValueType.STRING,
+                description: 'The name of the local variable to delete.',
+            },
+        ],
+        description: 'Deletes a local variable.',
+        returns: '',
+        exampleUsage: ['{{deletevar::myvar}}', '{{deletevar some-local-var}}'],
+        handler: ({ unnamedArgs: [name] }) => {
+            ctx.variables.local.del(name);
+            return '';
+        },
+    });
     // {{setglobalvar::name::value}} -> ''
     MacroRegistry.registerMacro('setglobalvar', {
         category: MacroCategory.VARIABLE,

         description: 'Increments a global variable by 1 and returns the new value. If the variable does not exist, it will be created.',
         returns: 'The new value of the global variable.',
         returnType: MacroValueType.NUMBER,
+        exampleUsage: ['{{incglobalvar::myintvar}}', '{{incglobalvar some-global-int-var}}'],
         handler: ({ unnamedArgs: [name], normalize }) => {
             const result = ctx.variables.global.inc(name);
             return normalize(result);

         description: 'Decrements a global variable by 1 and returns the new value. If the variable does not exist, it will be created.',
         returns: 'The new value of the global variable.',
         returnType: MacroValueType.NUMBER,
-        exampleUsage: ['{{decglobalvar::myintvar}}'],
+        exampleUsage: ['{{decglobalvar::myintvar}}', '{{decglobalvar some-global-int-var}}'],
         handler: ({ unnamedArgs: [name], normalize }) => {
             const result = ctx.variables.global.dec(name);
             return normalize(result);

         description: 'Gets the value of a global variable.',
         returns: 'The value of the global variable.',
         returnType: [MacroValueType.STRING, MacroValueType.NUMBER],
-        exampleUsage: ['{{getglobalvar::myvar}}', '{{getglobalvar::myintvar}}'],
+        exampleUsage: ['{{getglobalvar::myvar}}', '{{getglobalvar myintvar}}'],
         handler: ({ unnamedArgs: [name], normalize }) => {
             const result = ctx.variables.global.get(name);
             return normalize(result);
         },
     });
+    // {{hasglobalvar::name}} -> returns 'true' or 'false'
+    MacroRegistry.registerMacro('hasglobalvar', {
+        aliases: [{ alias: 'globalvarexists' }],
+        category: MacroCategory.VARIABLE,
+        unnamedArgs: [
+            {
+                name: 'name',
+                type: MacroValueType.STRING,
+                description: 'The name of the global variable to check.',
+            },
+        ],
+        description: 'Checks if a global variable exists.',
+        returns: '"true" if the variable exists, "false" otherwise.',
+        returnType: MacroValueType.STRING,
+        exampleUsage: ['{{hasglobalvar::myvar}}', '{{hasglobalvar some-global-var}}'],
+        handler: ({ unnamedArgs: [name] }) => {
+            return ctx.variables.global.has(name) ? 'true' : 'false';
+        },
+    });
+    // {{deleteglobalvar::name}} -> returns ''
+    MacroRegistry.registerMacro('deleteglobalvar', {
+        aliases: [{ alias: 'flushglobalvar' }],
+        category: MacroCategory.VARIABLE,
+        unnamedArgs: [
+            {
+                name: 'name',
+                type: MacroValueType.STRING,
+                description: 'The name of the global variable to delete.',
+            },
+        ],
+        description: 'Deletes a global variable.',
+        returns: '',
+        exampleUsage: ['{{deleteglobalvar::myvar}}', '{{deleteglobalvar some-global-var}}'],
+        handler: ({ unnamedArgs: [name] }) => {
+            ctx.variables.global.del(name);
+            return '';
+        },
+    });
+}

public/scripts/macros/engine/MacroCstWalker.js+186 -50 Viewed

 /** @typedef {import('./MacroEnv.types.js').MacroEnv} MacroEnv */
 /** @typedef {import('./MacroFlags.js').MacroFlags} MacroFlags */
+import { logMacroInternalError, logMacroRuntimeWarning } from './MacroDiagnostics.js';
+import { MacroEngine } from './MacroEngine.js';
 import { parseFlags, createEmptyFlags, MacroFlagType } from './MacroFlags.js';
 import { MacroParser } from './MacroParser.js';
 import { MacroRegistry } from './MacroRegistry.js';
+import { isFalseBoolean } from '/scripts/utils.js';
 /**
  * @typedef {Object} MacroCall

@@ -493,7 +496,10 @@ class MacroCstWalker {
493	}	496	}
494		497
495	/**	498	/**
496	* Evaluates a variable expression node and routes it to the appropriate variable macro.	499	* Evaluates a variable expression node using direct variable API calls.
		500	* Supports operators: get, set (=), add (+=), sub (-=), inc (++), dec (--),
		501	* logical or (\|\|), nullish coalescing (??), logical or assign (\|\|=),
		502	* nullish coalescing assign (??=), and equality comparison (==).
497	*	503	*
498	* @param {CstNode} macroNode - The parent macro node.	504	* @param {CstNode} macroNode - The parent macro node.
499	* @param {CstNode} variableExprNode - The variableExpr CST node.	505	* @param {CstNode} variableExprNode - The variableExpr CST node.

      * @returns {string}
      */
     #evaluateVariableExpr(macroNode, variableExprNode, context) {
-        const { text, contextOffset, env, resolveMacro } = context;
-        const children = macroNode.children || {};
         const varChildren = variableExprNode.children || {};
         // Extract scope (. for local, $ for global)

         const operatorNode = /** @type {CstNode?} */ ((varChildren.variableOperator || [])[0]);
         const operatorChildren = operatorNode?.children || {};
-        // Determine operation and value
+        // Determine operation and whether a value expression is expected
         let operation = 'get';
-        let value = null;
+        let hasValueExpr = false;
         if (operatorNode) {
             const operatorTokens = /** @type {IToken[]} */ (operatorChildren['Var.operator'] || []);

             if (operatorToken) {
                 const operatorImage = operatorToken.image;
-                if (operatorImage === '++') {
+                switch (operatorImage) {
-                    operation = 'inc';
+                    case '++':
-                } else if (operatorImage === '--') {
+                        operation = 'inc';
-                    operation = 'dec';
+                        break;
-                } else if (operatorImage === '=') {
+                    case '--':
-                    operation = 'set';
+                        operation = 'dec';
-                    value = this.#evaluateVariableValue(operatorChildren, context);
+                        break;
-                } else if (operatorImage === '+=') {
+                    case '=':
-                    operation = 'add';
+                        operation = 'set';
-                    value = this.#evaluateVariableValue(operatorChildren, context);
+                        hasValueExpr = true;
+                        break;
+                    case '+=':
+                        operation = 'add';
+                        hasValueExpr = true;
+                        break;
+                    case '-=':
+                        operation = 'sub';
+                        hasValueExpr = true;
+                        break;
+                    case '||':
+                        operation = 'logicalOr';
+                        hasValueExpr = true;
+                        break;
+                    case '??':
+                        operation = 'nullishCoalescing';
+                        hasValueExpr = true;
+                        break;
+                    case '||=':
+                        operation = 'logicalOrAssign';
+                        hasValueExpr = true;
+                        break;
+                    case '??=':
+                        operation = 'nullishCoalescingAssign';
+                        hasValueExpr = true;
+                        break;
+                    case '==':
+                        operation = 'equals';
+                        hasValueExpr = true;
+                        break;
+                    case '!=':
+                        operation = 'notEquals';
+                        hasValueExpr = true;
+                        break;
+                    default:
+                        logMacroInternalError({ message: `Lexer found macro operator that is not implemented for variable shorthand expressions in macro node '${macroNode.name}'.` });
+                        break;
+                }
+            }
+        }
-        // Map operation to macro name
+        // Create a lazy value resolver that caches its result on first call.
-        const macroNameMap = {
+        // This ensures the value expression is only evaluated when actually needed,
-            get: isGlobal ? 'getglobalvar' : 'getvar',
+        // which is important for performance and because some macros are stateful.
-            set: isGlobal ? 'setglobalvar' : 'setvar',
+        const lazyValue = hasValueExpr ? this.#createLazyValue(operatorChildren, context) : () => '';
-            inc: isGlobal ? 'incglobalvar' : 'incvar',
-            dec: isGlobal ? 'decglobalvar' : 'decvar',
+        // Execute the operation using direct variable API calls
-            add: isGlobal ? 'addglobalvar' : 'addvar',
+        return this.#executeVariableOperation(varName, isGlobal, operation, lazyValue);
+    }
+    /**
+     * Creates a lazy value resolver that caches its result on first call.
+     * This ensures the value expression is only evaluated when actually needed.
+     *
+     * @param {Record<string, any>} operatorChildren - The children of the variableOperator node.
+     * @param {EvaluationContext} context - The evaluation context.
+     * @returns {() => string} A function that returns the evaluated value, caching the result.
+     */
+    #createLazyValue(operatorChildren, context) {
+        let cached = null;
+        let resolved = false;
+        return () => {
+            if (!resolved) {
+                cached = this.#evaluateVariableValue(operatorChildren, context);
+                resolved = true;
+            }
+            return cached;
         };
+    }
-        const targetMacroName = macroNameMap[operation];
+    /**
+     * Executes a variable operation using the SillyTavern context API.
+     *
+     * @param {string} varName - The variable name.
+     * @param {boolean} isGlobal - Whether this is a global ($) or local (.) variable.
+     * @param {string} operation - The operation to perform.
+     * @param {() => string} lazyValue - A lazy function that returns the value when called. Only evaluated when needed.
+     * @returns {string} The result of the operation.
+     */
+    #executeVariableOperation(varName, isGlobal, operation, lazyValue) {
+        const ctx = SillyTavern.getContext();
+        const vars = isGlobal ? ctx.variables.global : ctx.variables.local;
+        /**
+        * Normalizes macro results into a string.
+        * @param {any} value
+        * @returns {string}
+        */
+        const normalize = MacroEngine.normalizeMacroResult.bind(MacroEngine);
+        /**
+         * Checks if a value is falsy (empty string, 0, '0', false, 'false', null, undefined).
+         * @param {any} val
+         * @returns {boolean}
+         */
+        const isFalsy = (val) => !val || isFalseBoolean(normalize(val));
+        switch (operation) {
+            case 'get':
+                return normalize(vars.get(varName));
+            case 'set':
+                vars.set(varName, lazyValue());
+                return '';
+            case 'inc':
+                return normalize(vars.inc(varName));
+            case 'dec':
+                return normalize(vars.dec(varName));
+            case 'add':
+                vars.add(varName, lazyValue());
+                return '';
+            case 'sub': {
+                // Subtract by adding the negative value
+                const numValue = Number(lazyValue());
+                if (!isNaN(numValue)) vars.add(varName, -numValue);
+                else logMacroRuntimeWarning({ message: `Variable shorthand "-=" operator requires a numeric value, got: "${lazyValue()}"` });
+                return '';
+            }
-        // Build args array based on operation
+            case 'logicalOr': {
-        const args = [varName];
+                // Returns default value if variable is falsy, otherwise returns variable value
-        if (value !== null) {
+                // Value is only resolved if needed (when variable is falsy)
-            args.push(value);
+                const currentValue = vars.get(varName);
-        }
+                return isFalsy(currentValue) ? normalize(lazyValue()) : normalize(currentValue);
+            }
-        const range = this.#getMacroRange(macroNode);
+            case 'nullishCoalescing': {
+                // Returns default value only if variable doesn't exist, otherwise returns variable value (even if falsy)
+                // Value is only resolved if needed (when variable doesn't exist)
+                const exists = vars.has(varName);
+                return exists ? normalize(vars.get(varName)) : normalize(lazyValue());
+            }
-        /** @type {MacroCall} */
+            case 'logicalOrAssign': {
-        const call = {
+                // If variable is falsy, set it to value and return value; otherwise return current value
-            name: targetMacroName,
+                // Value is only resolved if needed (when variable is falsy)
-            args,
+                const currentValue = vars.get(varName);
-            flags: createEmptyFlags(),
+                if (isFalsy(currentValue)) {
-            isScoped: false,
+                    vars.set(varName, lazyValue());
-            isVariableShorthand: true,
+                    return normalize(lazyValue());
-            rawInner: text.slice(
+                }
-                (/** @type {IToken|undefined} */ (children['Macro.Start']?.[0])?.endOffset ?? range.startOffset) + 1,
+                return normalize(currentValue);
-                (/** @type {IToken|undefined} */ (children['Macro.End']?.[0])?.startOffset ?? range.endOffset + 1) - 1,
+            }
-            ),
-            rawWithBraces: text.slice(range.startOffset, range.endOffset + 1),
-            rawArgs: args,
-            range,
-            globalOffset: contextOffset + range.startOffset,
-            cstNode: macroNode,
-            env,
-        };
-        const result = resolveMacro(call);
+            case 'nullishCoalescingAssign': {
-        return typeof result === 'string' ? result : String(result ?? '');
+                // If variable doesn't exist, set it to value and return value; otherwise return current value
+                // Value is only resolved if needed (when variable doesn't exist)
+                const exists = vars.has(varName);
+                if (!exists) {
+                    vars.set(varName, lazyValue());
+                    return normalize(lazyValue());
+                }
+                return normalize(vars.get(varName));
+            }
+            case 'equals': {
+                // String equality comparison - value is always needed
+                const currentValue = normalize(vars.get(varName));
+                const compareValue = normalize(lazyValue());
+                return currentValue === compareValue ? 'true' : 'false';
+            }
+            case 'notEquals': {
+                // String inequality comparison - value is always needed
+                const currentValue = normalize(vars.get(varName));
+                const compareValue = normalize(lazyValue());
+                return currentValue !== compareValue ? 'true' : 'false';
+            }
+            default:
+                logMacroRuntimeWarning({ message: `Unknown variable shorthand operation: "${operation}"` });
+                return '';
+        }
+    }
     /**

public/scripts/macros/engine/MacroLexer.js+38 -13 Viewed

          * Invalid: my-, my--, -var
          */
         Identifier: createToken({ name: 'Var.Identifier', pattern: MACRO_VARIABLE_SHORTHAND_PATTERN }),
-        /** Increment operator (`++`) */
-        Increment: createToken({ name: 'Var.Increment', pattern: /\+\+/ }),
+        /** All tokens that are valid operators inside a variable shorthand expression */
-        /** Decrement operator (`--`) */
+        Operators: {
-        Decrement: createToken({ name: 'Var.Decrement', pattern: /--/ }),
+            /** Increment operator (`++`) */
-        /** Add/append operator (`+=`) - must come before Equals to avoid conflict */
+            Increment: createToken({ name: 'Var.Increment', pattern: /\+\+/ }),
-        PlusEquals: createToken({ name: 'Var.PlusEquals', pattern: /\+=/ }),
+            /** Decrement operator (`--`) */
-        /** Set operator (`=`) */
+            Decrement: createToken({ name: 'Var.Decrement', pattern: /--/ }),
-        Equals: createToken({ name: 'Var.Equals', pattern: /=/ }),
+            /** Nullish coalescing assignment operator (`??=`) - sets var if undefined, must come before NullishCoalescing */
+            NullishCoalescingEquals: createToken({ name: 'Var.NullishCoalescingEquals', pattern: /\?\?=/ }),
+            /** Nullish coalescing operator (`??`) - returns default if var undefined */
+            NullishCoalescing: createToken({ name: 'Var.NullishCoalescing', pattern: /\?\?/ }),
+            /** Logical OR assignment operator (`||=`) - sets var if falsy, must come before LogicalOr */
+            LogicalOrEquals: createToken({ name: 'Var.LogicalOrEquals', pattern: /\|\|=/ }),
+            /** Logical OR operator (`||`) - returns default if var falsy */
+            LogicalOr: createToken({ name: 'Var.LogicalOr', pattern: /\|\|/ }),
+            /** Subtract operator (`-=`) - subtracts value from variable */
+            MinusEquals: createToken({ name: 'Var.MinusEquals', pattern: /-=/ }),
+            /** Equality comparison operator (`==`) - compares variable to value */
+            DoubleEquals: createToken({ name: 'Var.DoubleEquals', pattern: /==/ }),
+            /** Not equals comparison operator (`!=`) - compares variable to value, returns inverted result */
+            NotEquals: createToken({ name: 'Var.NotEquals', pattern: /!=/ }),
+            /** Add/append operator (`+=`) - must come before Equals to avoid conflict */
+            PlusEquals: createToken({ name: 'Var.PlusEquals', pattern: /\+=/ }),
+            /** Set operator (`=`) */
+            Equals: createToken({ name: 'Var.Equals', pattern: /=/ }),
+        },
     },
     /**

         // After the variable identifier, look for operators or end
         [modes.var_after_identifier]: [
             using(Tokens.WhiteSpace),
-            // Check for operators
+            // Check for operators - order matters: longer patterns first
-            using(Tokens.Var.Increment),
+            using(Tokens.Var.Operators.Increment),
-            using(Tokens.Var.Decrement),
+            using(Tokens.Var.Operators.Decrement),
-            enter(Tokens.Var.PlusEquals, modes.var_value, { andExits: modes.var_after_identifier }),
+            enter(Tokens.Var.Operators.NullishCoalescingEquals, modes.var_value, { andExits: modes.var_after_identifier }),
-            enter(Tokens.Var.Equals, modes.var_value, { andExits: modes.var_after_identifier }),
+            enter(Tokens.Var.Operators.NullishCoalescing, modes.var_value, { andExits: modes.var_after_identifier }),
+            enter(Tokens.Var.Operators.LogicalOrEquals, modes.var_value, { andExits: modes.var_after_identifier }),
+            enter(Tokens.Var.Operators.LogicalOr, modes.var_value, { andExits: modes.var_after_identifier }),
+            enter(Tokens.Var.Operators.MinusEquals, modes.var_value, { andExits: modes.var_after_identifier }),
+            enter(Tokens.Var.Operators.DoubleEquals, modes.var_value, { andExits: modes.var_after_identifier }),
+            enter(Tokens.Var.Operators.NotEquals, modes.var_value, { andExits: modes.var_after_identifier }),
+            enter(Tokens.Var.Operators.PlusEquals, modes.var_value, { andExits: modes.var_after_identifier }),
+            enter(Tokens.Var.Operators.Equals, modes.var_value, { andExits: modes.var_after_identifier }),
             // If we see the end, exit
             exits(Tokens.Macro.BeforeEnd, modes.var_after_identifier),
             // Fallback exit

public/scripts/macros/engine/MacroParser.js+48 -6 Viewed

             // Variable identifier (name)
             $.CONSUME(Tokens.Var.Identifier, { LABEL: 'Var.identifier' });
-            // Optional operator
+            // Optional operator (and expression, if operator requires one)
             $.OPTION2(() => $.SUBRULE($.variableOperator));
         });
-        // Variable operator: ++, --, = value, += value
+        // Variable operator: ++, --, = value, += value, -= value, ||, ??, ||=, ??=, ==, !=
         $.variableOperator = $.RULE('variableOperator', () => {
             $.OR4([
-                { ALT: () => $.CONSUME(Tokens.Var.Increment, { LABEL: 'Var.operator' }) },
+                { ALT: () => $.CONSUME(Tokens.Var.Operators.Increment, { LABEL: 'Var.operator' }) },
-                { ALT: () => $.CONSUME(Tokens.Var.Decrement, { LABEL: 'Var.operator' }) },
+                { ALT: () => $.CONSUME(Tokens.Var.Operators.Decrement, { LABEL: 'Var.operator' }) },
+                {
                     ALT: () => {
-                        $.CONSUME(Tokens.Var.Equals, { LABEL: 'Var.operator' });
+                        $.CONSUME(Tokens.Var.Operators.NullishCoalescingEquals, { LABEL: 'Var.operator' });
                         $.SUBRULE($.variableValue, { LABEL: 'Var.value' });
                     },
                 },
+                {
                     ALT: () => {
-                        $.CONSUME(Tokens.Var.PlusEquals, { LABEL: 'Var.operator' });
+                        $.CONSUME(Tokens.Var.Operators.NullishCoalescing, { LABEL: 'Var.operator' });
                         $.SUBRULE2($.variableValue, { LABEL: 'Var.value' });
                     },
                 },
+                {
+                    ALT: () => {
+                        $.CONSUME(Tokens.Var.Operators.LogicalOrEquals, { LABEL: 'Var.operator' });
+                        $.SUBRULE3($.variableValue, { LABEL: 'Var.value' });
+                    },
+                },
+                {
+                    ALT: () => {
+                        $.CONSUME(Tokens.Var.Operators.LogicalOr, { LABEL: 'Var.operator' });
+                        $.SUBRULE4($.variableValue, { LABEL: 'Var.value' });
+                    },
+                },
+                {
+                    ALT: () => {
+                        $.CONSUME(Tokens.Var.Operators.MinusEquals, { LABEL: 'Var.operator' });
+                        $.SUBRULE5($.variableValue, { LABEL: 'Var.value' });
+                    },
+                },
+                {
+                    ALT: () => {
+                        $.CONSUME(Tokens.Var.Operators.DoubleEquals, { LABEL: 'Var.operator' });
+                        $.SUBRULE6($.variableValue, { LABEL: 'Var.value' });
+                    },
+                },
+                {
+                    ALT: () => {
+                        $.CONSUME(Tokens.Var.Operators.NotEquals, { LABEL: 'Var.operator' });
+                        $.SUBRULE7($.variableValue, { LABEL: 'Var.value' });
+                    },
+                },
+                {
+                    ALT: () => {
+                        $.CONSUME(Tokens.Var.Operators.PlusEquals, { LABEL: 'Var.operator' });
+                        $.SUBRULE8($.variableValue, { LABEL: 'Var.value' });
+                    },
+                },
+                {
+                    ALT: () => {
+                        $.CONSUME(Tokens.Var.Operators.Equals, { LABEL: 'Var.operator' });
+                        $.SUBRULE9($.variableValue, { LABEL: 'Var.value' });
+                    },
+                },
             ]);
         });

public/scripts/slash-commands/SlashCommandParser.js+27 -1 Viewed

         return this.testSymbol('/');
+    }
     testCommandEnd() {
-        return this.testClosureEnd() || this.testSymbol('|');
+        if (this.testClosureEnd()) return true;
+        // Only treat | as command end if we're not inside macro braces {{}}
+        if (this.testSymbol('|') && !this.isInsideMacroBraces()) return true;
+        return false;
+    }
+    /**
+     * Checks if the current position is inside unclosed macro braces {{...}}.
+     * This prevents pipes inside macros from being treated as command separators.
+     * @returns {boolean} True if inside unclosed macro braces.
+     */
+    isInsideMacroBraces() {
+        const textBehind = this.behind;
+        let depth = 0;
+        // Scan through the text to track macro brace depth
+        for (let i = 0; i < textBehind.length; i++) {
+            if (textBehind[i] === '{' && textBehind[i + 1] === '{') {
+                depth++;
+                i++; // Skip the second {
+            } else if (textBehind[i] === '}' && textBehind[i + 1] === '}') {
+                depth = Math.max(0, depth - 1);
+                i++; // Skip the second }
+            }
+        }
+        return depth > 0;
+    }
     parseCommand() {
         const start = this.index + 1;

public/scripts/st-context.js+3 -1 Viewed

 import { ToolManager } from './tool-calling.js';
 import { accountStorage } from './util/AccountStorage.js';
 import { timestampToMoment, uuidv4 } from './utils.js';
-import { addGlobalVariable, addLocalVariable, decrementGlobalVariable, decrementLocalVariable, deleteGlobalVariable, deleteLocalVariable, getGlobalVariable, getLocalVariable, incrementGlobalVariable, incrementLocalVariable, setGlobalVariable, setLocalVariable } from './variables.js';
+import { addGlobalVariable, addLocalVariable, decrementGlobalVariable, decrementLocalVariable, deleteGlobalVariable, deleteLocalVariable, existsGlobalVariable, existsLocalVariable, getGlobalVariable, getLocalVariable, incrementGlobalVariable, incrementLocalVariable, setGlobalVariable, setLocalVariable } from './variables.js';
 import { convertCharacterBook, getWorldInfoPrompt, loadWorldInfo, reloadEditor, saveWorldInfo, updateWorldInfoList } from './world-info.js';
 import { ChatCompletionService, TextCompletionService } from './custom-request.js';
 import { ConnectionManagerRequestService } from './extensions/shared.js';

                 add: addLocalVariable,
                 inc: incrementLocalVariable,
                 dec: decrementLocalVariable,
+                has: existsLocalVariable,
             },
             global: {
                 get: getGlobalVariable,

                 add: addGlobalVariable,
                 inc: incrementGlobalVariable,
                 dec: decrementGlobalVariable,
+                has: existsGlobalVariable,
             },
         },
         loadWorldInfo,

public/scripts/variables.js+2 -2 Viewed

  * @param {string} name Local variable name
  * @returns {boolean} True if the local variable exists, false otherwise
  */
-function existsLocalVariable(name) {
+export function existsLocalVariable(name) {
     return chat_metadata.variables && chat_metadata.variables[name] !== undefined;
+}

  * @param {string} name Global variable name
  * @returns {boolean} True if the global variable exists, false otherwise
  */
-function existsGlobalVariable(name) {
+export function existsGlobalVariable(name) {
     return extension_settings.variables.global && extension_settings.variables.global[name] !== undefined;
+}

tests/frontend/MacroEngine.e2e.js+382 -0 Viewed

             // setvar returns '', incvar returns '6', addvar returns '', getvar returns '16'
             expect(output).toBe('616');
         });
+        // {{.myvar -= 5}} - subtract from local variable
+        test('should subtract from local variable with -= shorthand', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{.myvar -= 3}}Then: {{.myvar}}', { local: { myvar: '10' } });
+            // subvar returns '', then "Then: ", then getvar returns "7"
+            expect(output).toBe('Then: 7');
+        });
+        // {{$myvar -= 5}} - subtract from global variable
+        test('should subtract from global variable with -= shorthand', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{$myvar -= 5}}{{$myvar}}', { global: { myvar: '20' } });
+            expect(output).toBe('15');
+        });
+        // {{.myvar || default}} - returns default when falsy
+        test('should return default value with || when variable is falsy (empty)', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{.myvar || fallback}}', { local: { myvar: '' } });
+            expect(output).toBe('fallback');
+        });
+        test('should return default value with || when variable is falsy (zero)', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{.myvar || fallback}}', { local: { myvar: '0' } });
+            expect(output).toBe('fallback');
+        });
+        test('should return variable value with || when truthy', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{.myvar || fallback}}', { local: { myvar: 'existing' } });
+            expect(output).toBe('existing');
+        });
+        test('should return default value with || when variable does not exist', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{.nonexistent || default}}', { local: {} });
+            expect(output).toBe('default');
+        });
+        // {{.myvar ?? default}} - returns default only when undefined
+        test('should return default value with ?? when variable does not exist', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{.myvar ?? fallback}}', { local: {} });
+            expect(output).toBe('fallback');
+        });
+        test('should return empty string with ?? when variable exists but is empty', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '[{{.myvar ?? fallback}}]', { local: { myvar: '' } });
+            expect(output).toBe('[]');
+        });
+        test('should return zero with ?? when variable exists and is zero', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{.myvar ?? fallback}}', { local: { myvar: '0' } });
+            expect(output).toBe('0');
+        });
+        test('should return variable value with ?? when it exists', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{.myvar ?? fallback}}', { local: { myvar: 'value' } });
+            expect(output).toBe('value');
+        });
+        // {{.myvar ||= default}} - sets and returns default when falsy
+        test('should set and return default with ||= when variable is falsy', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{.myvar ||= newval}}{{.myvar}}', { local: { myvar: '' } });
+            // ||= returns 'newval', then getvar also returns 'newval'
+            expect(output).toBe('newvalnewval');
+        });
+        test('should not set and return current with ||= when variable is truthy', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{.myvar ||= newval}}{{.myvar}}', { local: { myvar: 'existing' } });
+            // ||= returns 'existing', then getvar returns 'existing'
+            expect(output).toBe('existingexisting');
+        });
+        test('should set and return default with ||= when variable does not exist', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{.myvar ||= created}}{{.myvar}}', { local: {} });
+            expect(output).toBe('createdcreated');
+        });
+        // {{.myvar ??= default}} - sets and returns default only when undefined
+        test('should set and return default with ??= when variable does not exist', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{.myvar ??= created}}{{.myvar}}', { local: {} });
+            expect(output).toBe('createdcreated');
+        });
+        test('should not set and return current with ??= when variable exists but is empty', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '[{{.myvar ??= newval}}][{{.myvar}}]', { local: { myvar: '' } });
+            // ??= returns '' (current value), then getvar returns '' (unchanged)
+            expect(output).toBe('[][]');
+        });
+        test('should not set and return current with ??= when variable exists and is zero', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{.myvar ??= newval}}{{.myvar}}', { local: { myvar: '0' } });
+            // ??= returns '0', then getvar returns '0'
+            expect(output).toBe('00');
+        });
+        // {{.myvar == value}} - equality comparison
+        test('should return true when variable equals value with ==', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{.myvar == hello}}', { local: { myvar: 'hello' } });
+            expect(output).toBe('true');
+        });
+        test('should return false when variable does not equal value with ==', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{.myvar == world}}', { local: { myvar: 'hello' } });
+            expect(output).toBe('false');
+        });
+        test('should compare empty variable correctly with ==', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{.myvar ==}}', { local: { myvar: '' } });
+            expect(output).toBe('true');
+        });
+        test('should compare numeric value correctly with ==', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{.myvar == 42}}', { local: { myvar: '42' } });
+            expect(output).toBe('true');
+        });
+        // {{.myvar != value}} - inequality comparison
+        test('should return true when variable does not equal value with !=', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{.myvar != world}}', { local: { myvar: 'hello' } });
+            expect(output).toBe('true');
+        });
+        test('should return false when variable equals value with !=', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{.myvar != hello}}', { local: { myvar: 'hello' } });
+            expect(output).toBe('false');
+        });
+        test('should compare empty variable correctly with !=', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{.myvar !=}}', { local: { myvar: '' } });
+            expect(output).toBe('false');
+        });
+        test('should compare non-empty to empty with !=', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{.myvar != }}', { local: { myvar: 'value' } });
+            expect(output).toBe('true');
+        });
+        test('should compare numeric value correctly with !=', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{.myvar != 99}}', { local: { myvar: '42' } });
+            expect(output).toBe('true');
+        });
+        // Global variable versions of new operators
+        test('should use || with global variable', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{$myvar || globaldefault}}', { global: { myvar: '' } });
+            expect(output).toBe('globaldefault');
+        });
+        test('should use ?? with global variable', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{$myvar ?? globaldefault}}', { global: {} });
+            expect(output).toBe('globaldefault');
+        });
+        test('should use ||= with global variable', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{$myvar ||= gset}}{{$myvar}}', { global: { myvar: '' } });
+            expect(output).toBe('gsetgset');
+        });
+        test('should use ??= with global variable', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{$myvar ??= gcreated}}{{$myvar}}', { global: {} });
+            expect(output).toBe('gcreatedgcreated');
+        });
+        test('should use == with global variable', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{$myvar == test}}', { global: { myvar: 'test' } });
+            expect(output).toBe('true');
+        });
+        // Nested macro in fallback value
+        test('should support nested macro in || fallback value', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{.myvar || Hello {{user}}}}', { local: {} });
+            expect(output).toBe('Hello User');
+        });
+        test('should support nested macro in ?? fallback value', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{.myvar ?? Hello {{user}}}}', { local: {} });
+            expect(output).toBe('Hello User');
+        });
+        // Whitespace handling with new operators
+        test('should handle whitespace with || operator', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{ .myvar || spaced }}', { local: {} });
+            expect(output).toBe('spaced');
+        });
+        test('should handle whitespace with ?? operator', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{ .myvar ?? spaced }}', { local: {} });
+            expect(output).toBe('spaced');
+        });
+    });
+    test.describe('Variable Shorthand Lazy Evaluation', () => {
+        // Tests to verify that fallback value expressions are only evaluated when needed.
+        // This is important for performance and because some macros are stateful.
+        // ?? should NOT evaluate fallback when variable exists
+        test('should NOT evaluate ?? fallback when variable exists', async ({ page }) => {
+            // Use setvar in the fallback - if lazy evaluation works, tracker should remain unset
+            const output = await evaluateWithEngineAndVariables(page, '{{.myvar ?? {{.tracker = evaluated}}fallback}}[{{.tracker}}]', { local: { myvar: 'exists' } });
+            // myvar exists, so ?? returns 'exists' and the fallback (which would set tracker) is NOT evaluated
+            expect(output).toBe('exists[]');
+        });
+        test('should evaluate ?? fallback when variable does not exist', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{.myvar ?? {{.tracker = evaluated}}fallback}}[{{.tracker}}]', { local: {} });
+            // myvar doesn't exist, so ?? evaluates and returns the fallback, setting tracker
+            expect(output).toBe('fallback[evaluated]');
+        });
+        // || should NOT evaluate fallback when variable is truthy
+        test('should NOT evaluate || fallback when variable is truthy', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{.myvar || {{.tracker = evaluated}}fallback}}[{{.tracker}}]', { local: { myvar: 'truthy' } });
+            // myvar is truthy, so || returns 'truthy' and the fallback is NOT evaluated
+            expect(output).toBe('truthy[]');
+        });
+        test('should evaluate || fallback when variable is falsy', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{.myvar || {{.tracker = evaluated}}fallback}}[{{.tracker}}]', { local: { myvar: '' } });
+            // myvar is falsy, so || evaluates and returns the fallback, setting tracker
+            expect(output).toBe('fallback[evaluated]');
+        });
+        // ??= should NOT evaluate value when variable exists
+        test('should NOT evaluate ??= value when variable exists', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{.myvar ??= {{.tracker = evaluated}}newval}}[{{.tracker}}]', { local: { myvar: 'exists' } });
+            // myvar exists, so ??= returns current value and the value expression is NOT evaluated
+            expect(output).toBe('exists[]');
+        });
+        test('should evaluate ??= value when variable does not exist', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{.myvar ??= {{.tracker = evaluated}}newval}}[{{.tracker}}]', { local: {} });
+            // myvar doesn't exist, so ??= evaluates value, sets myvar, and returns it
+            expect(output).toBe('newval[evaluated]');
+        });
+        // ||= should NOT evaluate value when variable is truthy
+        test('should NOT evaluate ||= value when variable is truthy', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{.myvar ||= {{.tracker = evaluated}}newval}}[{{.tracker}}]', { local: { myvar: 'truthy' } });
+            // myvar is truthy, so ||= returns current value and the value expression is NOT evaluated
+            expect(output).toBe('truthy[]');
+        });
+        test('should evaluate ||= value when variable is falsy', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{.myvar ||= {{.tracker = evaluated}}newval}}[{{.tracker}}]', { local: { myvar: '' } });
+            // myvar is falsy, so ||= evaluates value, sets myvar, and returns it
+            expect(output).toBe('newval[evaluated]');
+        });
+        // Operators that ALWAYS evaluate value should still work
+        test('should always evaluate = value expression', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{.myvar = {{.tracker = evaluated}}value}}[{{.tracker}}]', { local: {} });
+            expect(output).toBe('[evaluated]');
+        });
+        test('should always evaluate += value expression', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{.myvar += {{.tracker = evaluated}}5}}[{{.tracker}}]', { local: { myvar: '10' } });
+            expect(output).toBe('[evaluated]');
+        });
+        test('should always evaluate == value expression', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{.myvar == {{.tracker = evaluated}}test}}[{{.tracker}}]', { local: { myvar: 'test' } });
+            expect(output).toBe('true[evaluated]');
+        });
+        // Value should only be evaluated once (caching test)
+        test('should only evaluate value expression once when needed', async ({ page }) => {
+            // Use addvar to track how many times the value is evaluated (addvar returns empty string)
+            const output = await evaluateWithEngineAndVariables(page, '{{.counter = 0}}{{.myvar ??= {{.counter += 1}}value}}{{.counter}}', { local: {} });
+            // counter should be 1 (value evaluated exactly once)
+            expect(output).toBe('value1');
+        });
+    });
+    test.describe('Variable Shorthand Edge Cases', () => {
+        // Operators requiring a value but value is empty
+        test('should handle = operator with empty value', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{.myvar = }}[{{.myvar}}]', { local: {} });
+            // Empty value after = should set the variable to empty string
+            expect(output).toBe('[]');
+        });
+        test('should handle += operator with empty value', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{.myvar += }}[{{.myvar}}]', { local: { myvar: 'existing' } });
+            // Empty value after += should add nothing
+            expect(output).toBe('[existing]');
+        });
+        test('should handle -= operator with empty value (non-numeric)', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{.myvar -= }}[{{.myvar}}]', { local: { myvar: '10' } });
+            // Empty value is NaN, so subtraction fails silently and returns empty
+            expect(output).toBe('[10]');
+        });
+        test('should handle || operator with empty fallback', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '[{{.myvar || }}]', { local: { myvar: '' } });
+            // Falsy myvar, empty fallback - returns empty string
+            expect(output).toBe('[]');
+        });
+        test('should handle ?? operator with empty fallback', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '[{{.myvar ?? }}]', { local: {} });
+            // Undefined myvar, empty fallback - returns empty string
+            expect(output).toBe('[]');
+        });
+        test('should handle == operator with empty comparison value', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{.myvar == }}', { local: { myvar: '' } });
+            // Empty var equals empty value - should be true
+            expect(output).toBe('true');
+        });
+        test('should handle == operator comparing non-empty to empty', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{.myvar == }}', { local: { myvar: 'value' } });
+            // Non-empty var vs empty value - should be false
+            expect(output).toBe('false');
+        });
+        // Operators that don't take values - should return raw if invalid
+        test('should return raw with trailing content after ++ operator', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{.myvar++5}}', { local: { myvar: '5' } });
+            expect(output).toBe('{{.myvar++5}}');
+        });
+        test('should return empty with trailing content after -- operator', async ({ page }) => {
+            // This is a weird case. The "--" operator does not accept value expression, but writing it like this,
+            // makes the parser treat "myvar--5" as the variable identifier, as dashes and numbers are allowed.
+            // This is intended, so this resolving to null, as the variable does not exist, is also intended.
+            const output = await evaluateWithEngineAndVariables(page, '{{.myvar--5}}', { local: { myvar: '10' } });
+            expect(output).toBe('');
+        });
+        test('should return raw with trailing content after -- operator separated by spaces', async ({ page }) => {
+            // This is a weird case. The "--" operator does not accept value expression, but writing it like this,
+            // makes the parser treat "myvar--5" as the variable identifier, as dashes and numbers are allowed.
+            // This is intended, so this resolving to null, as the variable does not exist, is also intended.
+            const output = await evaluateWithEngineAndVariables(page, '{{.myvar -- 5}}', { local: { myvar: '10' } });
+            expect(output).toBe('{{.myvar -- 5}}');
+        });
     });
     test.describe('Variable Shorthand in {{if}} Macro', () => {

             expect(output).toBe('found');
         });
     });
+    test.describe('Variable Macros (hasvar, deletevar)', () => {
+        // {{hasvar::name}} - check if local variable exists
+        test('should return true when local variable exists', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{hasvar::myvar}}', { local: { myvar: 'value' } });
+            expect(output).toBe('true');
+        });
+        test('should return false when local variable does not exist', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{hasvar::nonexistent}}', { local: {} });
+            expect(output).toBe('false');
+        });
+        test('should return true when local variable exists but is empty', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{hasvar::myvar}}', { local: { myvar: '' } });
+            expect(output).toBe('true');
+        });
+        // {{hasglobalvar::name}} - check if global variable exists
+        test('should return true when global variable exists', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{hasglobalvar::myvar}}', { global: { myvar: 'value' } });
+            expect(output).toBe('true');
+        });
+        test('should return false when global variable does not exist', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{hasglobalvar::nonexistent}}', { global: {} });
+            expect(output).toBe('false');
+        });
+        // {{deletevar::name}} - delete local variable
+        test('should delete local variable', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{hasvar::myvar}}{{deletevar::myvar}}{{hasvar::myvar}}', { local: { myvar: 'value' } });
+            expect(output).toBe('truefalse');
+        });
+        // {{deleteglobalvar::name}} - delete global variable
+        test('should delete global variable', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{hasglobalvar::myvar}}{{deleteglobalvar::myvar}}{{hasglobalvar::myvar}}', { global: { myvar: 'value' } });
+            expect(output).toBe('truefalse');
+        });
+        // Combining hasvar with if
+        test('should use hasvar in if condition', async ({ page }) => {
+            const output = await evaluateWithEngineAndVariables(page, '{{if {{hasvar::myvar}} == true}}exists{{else}}missing{{/if}}', { local: { myvar: '' } });
+            expect(output).toBe('exists');
+        });
+    });
 });
 /**