@hyperfixi/core 2.9.0 → 2.9.2

package/dist/commands/index.js

@@ -153,7 +153,7 @@ function resolveElement(target, context, commandName) {
     if (!target) {
         const me = context.me;
         if (!me) {
-            throw new Error(withCmd(commandName, 'No target element — provide explicit target or ensure context.me is set'));
+            throw new Error(withCmd(commandName, 'No target element \u2014 provide explicit target or ensure context.me is set'));
         }
         return asHTMLElement(me);
     }
@@ -179,7 +179,7 @@ function resolveElement(target, context, commandName) {
         }
         const doc = context.me?.ownerDocument ?? (typeof document !== 'undefined' ? document : null);
         if (!doc) {
-            throw new Error(withCmd(commandName, 'DOM not available — cannot resolve element selector'));
+            throw new Error(withCmd(commandName, 'DOM not available \u2014 cannot resolve element selector'));
         }
         const element = doc.querySelector(trimmed);
         if (!element) {
@@ -635,39 +635,39 @@ const DEBUG = {
 const debug = {
     command: (...args) => {
         if (DEBUG.commands)
-            console.log('🔧', ...args);
+            console.log('\ud83d\udd27', ...args);
     },
     event: (...args) => {
         if (DEBUG.events)
-            console.log('🎯', ...args);
+            console.log('\ud83c\udfaf', ...args);
     },
     parse: (...args) => {
         if (DEBUG.parsing)
-            console.log('📝', ...args);
+            console.log('\ud83d\udcdd', ...args);
     },
     expr: (...args) => {
         if (DEBUG.expressions)
-            console.log('🔍', ...args);
+            console.log('\ud83d\udd0d', ...args);
     },
     expressions: (...args) => {
         if (DEBUG.expressions)
-            console.log('🔍', ...args);
+            console.log('\ud83d\udd0d', ...args);
     },
     style: (...args) => {
         if (DEBUG.styles)
-            console.log('🎨', ...args);
+            console.log('\ud83c\udfa8', ...args);
     },
     runtime: (...args) => {
         if (DEBUG.runtime)
-            console.log('🚀', ...args);
+            console.log('\ud83d\ude80', ...args);
     },
     loop: (...args) => {
         if (DEBUG.loops)
-            console.log('🔁', ...args);
+            console.log('\ud83d\udd01', ...args);
     },
     async: (...args) => {
         if (DEBUG.async)
-            console.log('⏳', ...args);
+            console.log('\u23f3', ...args);
     },
 };
 
@@ -6220,6 +6220,7 @@ function tokenize(input) {
             const prevToken = tokenizer.tokens[tokenizer.tokens.length - 1];
             const isPossessive = nextChar === 's' &&
                 prevToken &&
+                !/\s/.test(tokenizer.input[tokenizer.position - 1] ?? ' ') &&
                 (prevToken.kind === TokenKind.IDENTIFIER ||
                     prevToken.kind === TokenKind.SELECTOR ||
                     prevToken.value === ']' ||
@@ -6311,13 +6312,13 @@ function tokenize(input) {
             continue;
         }
         if (char === '{') {
-            addToken(tokenizer, TokenKind.OPERATOR, '{');
             advance(tokenizer);
+            addToken(tokenizer, TokenKind.OPERATOR, '{');
             continue;
         }
         if (char === '}') {
-            addToken(tokenizer, TokenKind.OPERATOR, '}');
             advance(tokenizer);
+            addToken(tokenizer, TokenKind.OPERATOR, '}');
             continue;
         }
         if (char === '[') {
@@ -6333,24 +6334,24 @@ function tokenize(input) {
                     prevToken.value === ']') &&
                 !isEventCondition;
             if (isMemberAccess) {
-                addToken(tokenizer, TokenKind.OPERATOR, '[');
                 advance(tokenizer);
+                addToken(tokenizer, TokenKind.OPERATOR, '[');
             }
             else {
                 if (isEventCondition) {
-                    addToken(tokenizer, TokenKind.SYMBOL, '[');
                     advance(tokenizer);
+                    addToken(tokenizer, TokenKind.SYMBOL, '[');
                 }
                 else {
-                    addToken(tokenizer, TokenKind.OPERATOR, '[');
                     advance(tokenizer);
+                    addToken(tokenizer, TokenKind.OPERATOR, '[');
                 }
             }
             continue;
         }
         if (char === ']') {
-            addToken(tokenizer, TokenKind.OPERATOR, ']');
             advance(tokenizer);
+            addToken(tokenizer, TokenKind.OPERATOR, ']');
             continue;
         }
         if (char === '$') {
@@ -7944,9 +7945,9 @@ function createPartialCommandNode(name, pos) {
     };
 }
 function createProgramNode(statements) {
-    debug.parse(`✅ createProgramNode: Called with ${statements.length} statements`);
+    debug.parse(`\u2705 createProgramNode: Called with ${statements.length} statements`);
     if (statements.length === 0) {
-        debug.parse(`✅ createProgramNode: Returning error node (0 statements)`);
+        debug.parse(`\u2705 createProgramNode: Returning error node (0 statements)`);
         return {
             type: 'identifier',
             name: '__ERROR__',
@@ -7957,7 +7958,7 @@ function createProgramNode(statements) {
         };
     }
     if (statements.length === 1) {
-        debug.parse(`✅ createProgramNode: Returning single statement (type=${statements[0].type})`);
+        debug.parse(`\u2705 createProgramNode: Returning single statement (type=${statements[0].type})`);
         return statements[0];
     }
     const programNode = {
@@ -7968,7 +7969,7 @@ function createProgramNode(statements) {
         line: statements[0]?.line || 1,
         column: statements[0]?.column || 1,
     };
-    debug.parse(`✅ createProgramNode: Returning Program node with ${statements.length} statements, type=${programNode.type}`);
+    debug.parse(`\u2705 createProgramNode: Returning Program node with ${statements.length} statements, type=${programNode.type}`);
     return programNode;
 }
 
@@ -7979,7 +7980,6 @@ const MULTI_WORD_PATTERNS = [
         keywords: ['a', 'an', 'from', 'called'],
         syntax: 'make (a|an) <type> [from <args>] [called <name>]',
     },
-    { command: 'send', keywords: ['to'], syntax: 'send <event> to <target>' },
     { command: 'throw', keywords: [], syntax: 'throw <error>' },
 ];
 function getMultiWordPattern(commandName) {
@@ -8280,7 +8280,13 @@ function parseTriggerCommand(ctx, identifierNode) {
             finalArgs.push(ctx.createIdentifier(keyword));
             continue;
         }
-        finalArgs.push(ctx.parsePrimary());
+        const before = ctx.savePosition();
+        const expr = ctx.parsePrimary();
+        if (expr)
+            finalArgs.push(expr);
+        if (ctx.savePosition() === before) {
+            ctx.advance();
+        }
     }
     return CommandNodeBuilder.fromIdentifier(identifierNode)
         .withArgs(...finalArgs)
@@ -8357,37 +8363,37 @@ function parseRepeatCommand(ctx, commandToken) {
             ctx.advance();
             loopType = 'until-event';
             const eventToken = ctx.peek();
-            debug.parse('📍 Parsing event name, current token:', {
+            debug.parse('\ud83d\udccd Parsing event name, current token:', {
                 value: eventToken.value,
                 kind: eventToken.kind,
             });
             if (isIdentifierLike(eventToken) || isEvent(eventToken)) {
                 eventName = eventToken.value;
                 ctx.advance();
-                debug.parse('✅ Got event name:', eventName, 'Next token:', ctx.peek().value);
+                debug.parse('\u2705 Got event name:', eventName, 'Next token:', ctx.peek().value);
             }
             else {
                 throw new Error('Expected event name after "event"');
             }
-            debug.parse('🔍 Checking for "from", current token:', ctx.peek().value);
+            debug.parse('\ud83d\udd0d Checking for "from", current token:', ctx.peek().value);
             if (ctx.check(KEYWORDS$1.FROM)) {
-                debug.parse('✅ Found "from", advancing...');
+                debug.parse('\u2705 Found "from", advancing...');
                 ctx.advance();
-                debug.parse('📍 After consuming "from", current token:', ctx.peek().value);
+                debug.parse('\ud83d\udccd After consuming "from", current token:', ctx.peek().value);
                 if (consumeOptionalKeyword(ctx, KEYWORDS$1.THE)) {
-                    debug.parse('✅ Found "the", advancing...');
+                    debug.parse('\u2705 Found "the", advancing...');
                 }
                 const beforePrimary = ctx.peek();
-                debug.parse('🔍 Before parsePrimary for event target:', {
+                debug.parse('\ud83d\udd0d Before parsePrimary for event target:', {
                     value: beforePrimary.value,
                     kind: beforePrimary.kind,
                     position: beforePrimary.start,
                 });
                 eventTarget = ctx.parsePrimary();
-                debug.parse('✅ After parsePrimary, eventTarget:', eventTarget);
+                debug.parse('\u2705 After parsePrimary, eventTarget:', eventTarget);
             }
             else {
-                debug.parse('❌ No "from" found, skipping target parsing');
+                debug.parse('\u274c No "from" found, skipping target parsing');
             }
         }
         else {
@@ -8499,11 +8505,64 @@ function parseRepeatCommand(ctx, commandToken) {
     }
     return builder.endingAt(ctx.getPosition()).build();
 }
+function parseIfBranchCommands(ctx, stopAtElse) {
+    const commands = [];
+    const atTerminator = () => ctx.check(KEYWORDS$1.END) || (stopAtElse && ctx.check(KEYWORDS$1.ELSE));
+    while (!ctx.isAtEnd() && !atTerminator()) {
+        if (isComment(ctx.peek())) {
+            ctx.advance();
+            continue;
+        }
+        if (!ctx.checkIsCommand() && !ctx.isCommand(ctx.peek().value))
+            break;
+        ctx.advance();
+        const cmd = ctx.parseCommand();
+        if (cmd) {
+            commands.push(cmd);
+        }
+        if (ctx.check(KEYWORDS$1.THEN) || ctx.check(KEYWORDS$1.AND) || ctx.check(',')) {
+            ctx.advance();
+        }
+    }
+    return commands;
+}
+const OPERAND_INTRODUCERS = new Set([
+    'is',
+    'am',
+    'are',
+    'not',
+    'no',
+    'and',
+    'or',
+    '==',
+    '===',
+    '!=',
+    '!==',
+    '<',
+    '>',
+    '<=',
+    '>=',
+    '+',
+    '-',
+    '*',
+    '/',
+    'mod',
+]);
+function isBodyCommandStart(ctx, prevToken, token) {
+    if (prevToken === null) {
+        return false;
+    }
+    if (OPERAND_INTRODUCERS.has(prevToken.value?.toLowerCase?.() ?? '')) {
+        return false;
+    }
+    return ctx.checkIsCommand() || ctx.isCommand(token.value?.toLowerCase());
+}
 function parseIfCommand(ctx, commandToken) {
     const args = [];
     let hasThen = false;
     const savedPosForThen = ctx.savePosition();
     const maxThenLookahead = 500;
+    let prevForThen = null;
     for (let i = 0; i < maxThenLookahead && !ctx.isAtEnd(); i++) {
         const token = ctx.peek();
         if (token.value === KEYWORDS$1.THEN) {
@@ -8516,6 +8575,14 @@ function parseIfCommand(ctx, commandToken) {
             token.value === KEYWORDS$1.ON) {
             break;
         }
+        if (token.line !== undefined &&
+            token.line !== commandToken.line &&
+            isBodyCommandStart(ctx, prevForThen, token)) {
+            break;
+        }
+        if (!isComment(token)) {
+            prevForThen = token;
+        }
         ctx.advance();
     }
     ctx.restorePosition(savedPosForThen);
@@ -8524,9 +8591,14 @@ function parseIfCommand(ctx, commandToken) {
         const savedPosition = ctx.savePosition();
         const ifStatementLine = commandToken.line;
         const maxLookahead = 100;
+        let firstCommandOnIfLine = false;
+        let prevToken = null;
         while (!ctx.isAtEnd() && ctx.current - savedPosition < maxLookahead) {
             const token = ctx.peek();
             const tokenValue = token.value?.toLowerCase();
+            if (firstCommandOnIfLine && token.line !== undefined && token.line !== ifStatementLine) {
+                break;
+            }
             if (tokenValue === KEYWORDS$1.BEHAVIOR ||
                 tokenValue === KEYWORDS$1.DEF ||
                 tokenValue === KEYWORDS$1.ON) {
@@ -8538,11 +8610,15 @@ function parseIfCommand(ctx, commandToken) {
                 }
                 break;
             }
-            if (ctx.checkIsCommand() || ctx.isCommand(tokenValue)) {
+            if (isBodyCommandStart(ctx, prevToken, token)) {
                 if (token.line !== undefined && token.line !== ifStatementLine) {
                     hasImplicitMultiLineEnd = true;
                     break;
                 }
+                firstCommandOnIfLine = true;
+            }
+            if (!isComment(token)) {
+                prevToken = token;
             }
             ctx.advance();
         }
@@ -8557,11 +8633,12 @@ function parseIfCommand(ctx, commandToken) {
         const conditionTokens = [];
         const maxIterations = 20;
         let iterations = 0;
+        let firstConditionParse = true;
         while (!ctx.isAtEnd() &&
-            !ctx.checkIsCommand() &&
-            !ctx.isCommand(ctx.peek().value) &&
             !ctx.check(KEYWORDS$1.THEN) &&
+            (firstConditionParse || (!ctx.checkIsCommand() && !ctx.isCommand(ctx.peek().value))) &&
             iterations < maxIterations) {
+            firstConditionParse = false;
             const beforePos = ctx.savePosition();
             conditionTokens.push(ctx.parseLogicalAnd());
             if (ctx.savePosition() === beforePos) {
@@ -8588,22 +8665,8 @@ function parseIfCommand(ctx, commandToken) {
     }
     args.push(condition);
     if (isMultiLine) {
-        if (hasThen) {
-            ctx.advance();
-        }
-        const thenCommands = [];
-        while (!ctx.isAtEnd() && !ctx.check(KEYWORDS$1.ELSE) && !ctx.check(KEYWORDS$1.END)) {
-            if (ctx.checkIsCommand() || ctx.isCommand(ctx.peek().value)) {
-                ctx.advance();
-                const cmd = ctx.parseCommand();
-                if (cmd) {
-                    thenCommands.push(cmd);
-                }
-            }
-            else {
-                break;
-            }
-        }
+        consumeOptionalKeyword(ctx, KEYWORDS$1.THEN);
+        const thenCommands = parseIfBranchCommands(ctx, true);
         if (thenCommands.length === 0 && ctx.isAtEnd()) {
             throw new Error("Expected command after 'then' in if statement - incomplete conditional");
         }
@@ -8629,19 +8692,7 @@ function parseIfCommand(ctx, commandToken) {
                 consumedElseIf = true;
             }
             else {
-                const elseCommands = [];
-                while (!ctx.isAtEnd() && !ctx.check(KEYWORDS$1.END)) {
-                    if (ctx.checkIsCommand() || ctx.isCommand(ctx.peek().value)) {
-                        ctx.advance();
-                        const cmd = ctx.parseCommand();
-                        if (cmd) {
-                            elseCommands.push(cmd);
-                        }
-                    }
-                    else {
-                        break;
-                    }
-                }
+                const elseCommands = parseIfBranchCommands(ctx, false);
                 args.push(createBlock(elseCommands, {
                     start: commandToken.start,
                     end: ctx.getPosition().end,
@@ -9463,21 +9514,6 @@ const GO_KEYWORDS = new Set([
     'back',
     'forward',
 ]);
-const GO_URL_STOP = new Set([
-    'in',
-    'then',
-    'and',
-    'else',
-    'end',
-    'otherwise',
-    'when',
-    'where',
-    'catch',
-    'finally',
-]);
-function isGoURLTerminator(ctx) {
-    return ctx.isAtEnd() || GO_URL_STOP.has(ctx.peek().value);
-}
 function stringNode(value, tok) {
     return {
         type: 'string',
@@ -9488,16 +9524,6 @@ function stringNode(value, tok) {
         column: tok.column,
     };
 }
-function isNakedURLStart(ctx) {
-    const tok = ctx.peek();
-    if (tok.value === '/')
-        return true;
-    if (ctx.checkIdentifierLike()) {
-        const next = ctx.peekAt(1);
-        return !!next && next.value === ':' && next.start === tok.end;
-    }
-    return false;
-}
 function parseGoCommand(ctx, identifierNode) {
     const args = [];
     while (!isCommandBoundary(ctx, ['when', 'where', 'catch', 'finally'])) {
@@ -9509,7 +9535,7 @@ function parseGoCommand(ctx, identifierNode) {
             continue;
         }
         if (isNakedURLStart(ctx)) {
-            const url = parseBareURLPath(ctx, isGoURLTerminator);
+            const url = parseBareURLPath(ctx);
             if (url) {
                 args.push(url);
                 continue;
@@ -9649,35 +9675,65 @@ function parseMultiWordCommand(ctx, commandToken, commandName) {
     }
     return builder.build();
 }
-function isFetchURLTerminator(ctx) {
-    if (ctx.isAtEnd())
+function isNakedURLStart(ctx) {
+    const tok = ctx.peek();
+    if (tok.value === '/')
         return true;
-    const val = ctx.peek().value;
-    return (['as', 'with', '{', 'then', 'end', 'else', 'otherwise', ')'].includes(val) ||
-        isCommandBoundary(ctx));
+    if (ctx.checkIdentifierLike()) {
+        const next = ctx.peekAt(1);
+        return !!next && next.value === ':' && next.start === tok.end;
+    }
+    return false;
 }
-function parseBareURLPath(ctx, isTerminator = isFetchURLTerminator) {
+const URL_HARD_STOPS = new Set(['{', ')']);
+function parseBareURLPath(ctx) {
     const startPos = ctx.savePosition();
+    const firstTok = ctx.peek();
     let path = '';
-    while (!ctx.isAtEnd() && !isTerminator(ctx)) {
-        path += ctx.advance().value;
+    let prev = null;
+    while (!ctx.isAtEnd()) {
+        const tok = ctx.peek();
+        if (prev && tok.start !== prev.end)
+            break;
+        if (tok.value === '$' && ctx.peekAt(1)?.value === '{') {
+            ctx.advance();
+            let last = ctx.advance();
+            let depth = 1;
+            while (!ctx.isAtEnd() && depth > 0) {
+                last = ctx.advance();
+                if (last.value === '{')
+                    depth++;
+                else if (last.value === '}')
+                    depth--;
+            }
+            path += ctx.getInputSlice(tok.start, last.end);
+            prev = last;
+            continue;
+        }
+        if (URL_HARD_STOPS.has(tok.value))
+            break;
+        prev = ctx.advance();
+        path += prev.value;
     }
     if (!path || path === '/') {
         ctx.restorePosition(startPos);
         return null;
     }
-    return {
-        type: 'literal',
-        value: path,
-        raw: path,
-        start: startPos,
-        end: ctx.savePosition(),
+    const span = {
+        start: firstTok.start,
+        end: prev ? prev.end : firstTok.end,
+        line: firstTok.line,
+        column: firstTok.column,
     };
+    if (path.includes('${')) {
+        return { type: 'templateLiteral', value: path, ...span };
+    }
+    return { type: 'literal', value: path, raw: path, ...span };
 }
 function parseFetchCommand(ctx, commandToken) {
     const modifiers = {};
     let url = null;
-    if (!ctx.isAtEnd() && ctx.check('/')) {
+    if (!ctx.isAtEnd() && isNakedURLStart(ctx)) {
         url = parseBareURLPath(ctx);
     }
     if (!url) {
@@ -9903,10 +9959,10 @@ function parseTellCommand(ctx, identifierNode) {
             catch {
                 break;
             }
-            if (ctx.match(KEYWORDS$1.AND)) {
+            if (ctx.match(KEYWORDS$1.AND) || ctx.match(KEYWORDS$1.THEN)) {
                 continue;
             }
-            if (ctx.check(KEYWORDS$1.THEN) || ctx.check(KEYWORDS$1.ELSE) || ctx.check(KEYWORDS$1.END)) {
+            if (ctx.check(KEYWORDS$1.ELSE) || ctx.check(KEYWORDS$1.END)) {
                 break;
             }
             if (ctx.checkIsCommand()) {
@@ -10109,6 +10165,7 @@ class Parser {
         const result = this.parseInternal();
         if (this.errors.length > 0) {
             result.errors = [...this.errors];
+            result.recovered = true;
         }
         return result;
     }
@@ -10243,26 +10300,26 @@ class Parser {
                 const commandSequence = this.parseCommandSequence();
                 if (commandSequence) {
                     if (!this.isAtEnd() && this.check('on')) {
-                        debug.parse('✅ PARSER: Found event handlers after command sequence, parsing as program');
+                        debug.parse('\u2705 PARSER: Found event handlers after command sequence, parsing as program');
                         const statements = [commandSequence];
-                        debug.parse(`✅ PARSER: Starting with ${statements.length} statement(s) from command sequence`);
+                        debug.parse(`\u2705 PARSER: Starting with ${statements.length} statement(s) from command sequence`);
                         let eventHandlerCount = 0;
                         while (!this.isAtEnd() && this.check('on')) {
-                            debug.parse(`✅ PARSER: Parsing event handler #${eventHandlerCount + 1}, current token: ${this.peek().value}`);
+                            debug.parse(`\u2705 PARSER: Parsing event handler #${eventHandlerCount + 1}, current token: ${this.peek().value}`);
                             this.advance();
                             const eventHandler = this.parseEventHandler();
-                            debug.parse(`✅ PARSER: parseEventHandler returned:`, eventHandler
+                            debug.parse(`\u2705 PARSER: parseEventHandler returned:`, eventHandler
                                 ? `type=${eventHandler.type}, event=${eventHandler.event}`
                                 : 'null');
                             if (eventHandler) {
                                 statements.push(eventHandler);
                                 eventHandlerCount++;
-                                debug.parse(`✅ PARSER: Added event handler, now have ${statements.length} statements total`);
+                                debug.parse(`\u2705 PARSER: Added event handler, now have ${statements.length} statements total`);
                             }
-                            debug.parse(`✅ PARSER: After parsing event handler, current token: ${this.isAtEnd() ? 'END' : this.peek().value}, isAtEnd=${this.isAtEnd()}, check('on')=${this.check('on')}`);
+                            debug.parse(`\u2705 PARSER: After parsing event handler, current token: ${this.isAtEnd() ? 'END' : this.peek().value}, isAtEnd=${this.isAtEnd()}, check('on')=${this.check('on')}`);
                             if (!this.isAtEnd() && !this.check('on')) {
                                 if (!this.isAtEnd()) {
-                                    debug.parse(`⚠️ PARSER: Unexpected token after event handlers: ${this.peek().value}`);
+                                    debug.parse(`\u26a0\ufe0f PARSER: Unexpected token after event handlers: ${this.peek().value}`);
                                     this.addError(`Unexpected token after event handlers: ${this.peek().value}`);
                                     return {
                                         success: false,
@@ -10271,11 +10328,11 @@ class Parser {
                                         error: this.error,
                                     };
                                 }
-                                debug.parse(`✅ PARSER: No more event handlers, at end of input`);
+                                debug.parse(`\u2705 PARSER: No more event handlers, at end of input`);
                                 break;
                             }
                         }
-                        debug.parse(`✅ PARSER: Finished parsing, creating Program node with ${statements.length} statements`);
+                        debug.parse(`\u2705 PARSER: Finished parsing, creating Program node with ${statements.length} statements`);
                         if (this.error) {
                             return {
                                 success: false,
@@ -10670,41 +10727,41 @@ class Parser {
     parseCommandListUntilTerminator(extraStops) {
         const commands = [];
         const isStop = () => this.check('end') || extraStops.some(s => this.check(s));
-        debug.parse('🔄 parseCommandListUntilTerminator: Starting (extraStops:', extraStops.join(','), ')');
+        debug.parse('\ud83d\udd04 parseCommandListUntilTerminator: Starting (extraStops:', extraStops.join(','), ')');
         while (!this.isAtEnd() && !isStop()) {
-            debug.parse('📍 Loop iteration, current token:', this.peek().value, 'kind:', this.peek().kind);
+            debug.parse('\ud83d\udccd Loop iteration, current token:', this.peek().value, 'kind:', this.peek().kind);
             let parsedCommand = false;
             const isCommandToken = this.checkIsCommand();
             const isCommandIdentifier = !isCommandToken && this.checkIdentifier() && this.isCommand(this.peek().value);
             if (isCommandToken || isCommandIdentifier) {
-                debug.parse(isCommandToken ? '✅ Found COMMAND token:' : '✅ Found IDENTIFIER that is a command:', this.peek().value);
+                debug.parse(isCommandToken ? '\u2705 Found COMMAND token:' : '\u2705 Found IDENTIFIER that is a command:', this.peek().value);
                 this.advance();
                 const savedError = this.error;
                 try {
                     const cmd = this.parseCommand();
                     if (this.error && this.error !== savedError) {
-                        debug.parse('⚠️  parseCommandListUntilTerminator: Command parsing added error, restoring. Error was:', this.error.message);
+                        debug.parse('\u26a0\ufe0f  parseCommandListUntilTerminator: Command parsing added error, restoring. Error was:', this.error.message);
                         this.error = savedError;
                     }
                     if (cmd) {
-                        debug.parse('✅ Parsed command:', cmd.name);
+                        debug.parse('\u2705 Parsed command:', cmd.name);
                         commands.push(cmd);
                         parsedCommand = true;
                     }
                 }
                 catch (error) {
-                    debug.parse('⚠️  parseCommandListUntilTerminator: Command parsing threw, restoring:', error instanceof Error ? error.message : String(error));
+                    debug.parse('\u26a0\ufe0f  parseCommandListUntilTerminator: Command parsing threw, restoring:', error instanceof Error ? error.message : String(error));
                     this.error = savedError;
                 }
             }
             else if (this.checkIdentifier()) {
-                debug.parse('❌ IDENTIFIER is not a command:', this.peek().value);
+                debug.parse('\u274c IDENTIFIER is not a command:', this.peek().value);
             }
             if (!parsedCommand) {
-                debug.parse('❌ No command parsed, breaking. Current token:', this.peek().value);
+                debug.parse('\u274c No command parsed, breaking. Current token:', this.peek().value);
                 break;
             }
-            debug.parse('📍 After parsing command, current token:', this.peek().value);
+            debug.parse('\ud83d\udccd After parsing command, current token:', this.peek().value);
             while (!this.isAtEnd() &&
                 !isStop() &&
                 !this.checkIsCommand() &&
@@ -10712,19 +10769,19 @@ class Parser {
                 !this.check('then') &&
                 !this.check('and') &&
                 !this.check(',')) {
-                debug.parse('⚠️  Skipping unexpected token:', this.peek().value);
+                debug.parse('\u26a0\ufe0f  Skipping unexpected token:', this.peek().value);
                 this.advance();
             }
             if (this.match('then', 'and', ',')) {
-                debug.parse('✅ Found separator, continuing');
+                debug.parse('\u2705 Found separator, continuing');
                 continue;
             }
             else if (this.checkIsCommand() || this.isCommand(this.peek().value)) {
-                debug.parse('✅ Next token is a command, continuing without separator');
+                debug.parse('\u2705 Next token is a command, continuing without separator');
                 continue;
             }
             else {
-                debug.parse('📍 No separator and no command, breaking. Current token:', this.peek().value);
+                debug.parse('\ud83d\udccd No separator and no command, breaking. Current token:', this.peek().value);
                 break;
             }
         }
@@ -10738,18 +10795,18 @@ class Parser {
         if (!this.check('end') && !extraStops.some(s => this.check(s))) {
             terminator = '';
         }
-        debug.parse('✅ parseCommandListUntilTerminator: parsed', commands.length, 'commands (terminator:', terminator, ')');
+        debug.parse('\u2705 parseCommandListUntilTerminator: parsed', commands.length, 'commands (terminator:', terminator, ')');
         return { commands, terminator };
     }
     parseCommandListUntilEnd() {
         const { commands } = this.parseCommandListUntilTerminator([]);
-        debug.parse('🔍 After loop, checking for "end". Current token:', this.peek().value);
+        debug.parse('\ud83d\udd0d After loop, checking for "end". Current token:', this.peek().value);
         if (this.check('end')) {
-            debug.parse('✅ Found "end", consuming it');
+            debug.parse('\u2705 Found "end", consuming it');
             this.advance();
         }
         else {
-            debug.parse('❌ ERROR: Expected "end" but got:', this.peek().value, 'at position:', this.peek().start);
+            debug.parse('\u274c ERROR: Expected "end" but got:', this.peek().value, 'at position:', this.peek().start);
             throw new Error('Expected "end" to close repeat block');
         }
         return commands;
@@ -11422,6 +11479,23 @@ class Parser {
             this.consume(')', "Expected ')' after parameter list");
         }
         const bodyCommands = this.parseCommandBlock(['end', 'catch', 'finally']);
+        const { errorSymbol, errorHandler, finallyHandler } = this.parseErrorAndFinallyBlocks();
+        this.consume('end', "Expected 'end' after function definition");
+        return {
+            type: 'def',
+            name: funcName,
+            params,
+            body: bodyCommands,
+            ...(errorSymbol !== undefined && { errorSymbol }),
+            ...(errorHandler !== undefined && { errorHandler }),
+            ...(finallyHandler !== undefined && { finallyHandler }),
+            start: pos.start,
+            end: this.getPosition().end,
+            line: pos.line,
+            column: pos.column,
+        };
+    }
+    parseErrorAndFinallyBlocks() {
         let errorSymbol;
         let errorHandler;
         if (this.check('catch')) {
@@ -11436,19 +11510,10 @@ class Parser {
             this.advance();
             finallyHandler = this.parseCommandBlock(['end']);
         }
-        this.consume('end', "Expected 'end' after function definition");
         return {
-            type: 'def',
-            name: funcName,
-            params,
-            body: bodyCommands,
             ...(errorSymbol !== undefined && { errorSymbol }),
             ...(errorHandler !== undefined && { errorHandler }),
             ...(finallyHandler !== undefined && { finallyHandler }),
-            start: pos.start,
-            end: this.getPosition().end,
-            line: pos.line,
-            column: pos.column,
         };
     }
     parseEventNameWithNamespace(errorMessage) {
@@ -11593,13 +11658,13 @@ class Parser {
         try {
             const cmd = this.parseCommand();
             if (this.error && this.error !== savedError) {
-                debug.parse('⚠️ Command parsing added error, restoring error state. Error was:', this.error.message);
+                debug.parse('\u26a0\ufe0f Command parsing added error, restoring error state. Error was:', this.error.message);
                 this.error = savedError;
             }
             return cmd;
         }
         catch (error) {
-            debug.parse('⚠️ Command parsing threw exception, restoring error state:', error instanceof Error ? error.message : String(error));
+            debug.parse('\u26a0\ufe0f Command parsing threw exception, restoring error state:', error instanceof Error ? error.message : String(error));
             this.error = savedError;
             return null;
         }
@@ -11616,12 +11681,12 @@ class Parser {
                 const timeToken = this.advance();
                 const delayMs = parseTimeToMs(timeToken.value);
                 modifiers[modifierKey] = delayMs;
-                debug.parse(`🔧 parseEventHandler: Parsed '${modName} at ${timeToken.value}' (${delayMs}ms)`);
+                debug.parse(`\ud83d\udd27 parseEventHandler: Parsed '${modName} at ${timeToken.value}' (${delayMs}ms)`);
             }
             else if (this.matchNumber()) {
                 const delayMs = parseInt(this.previous().value, 10);
                 modifiers[modifierKey] = delayMs;
-                debug.parse(`🔧 parseEventHandler: Parsed '${modName} at ${delayMs}'`);
+                debug.parse(`\ud83d\udd27 parseEventHandler: Parsed '${modName} at ${delayMs}'`);
             }
             else {
                 this.addError(`Expected time expression after '${modName} at', got: ${this.peek().value}`);
@@ -11632,7 +11697,7 @@ class Parser {
         }
     }
     parseEventHandler() {
-        debug.parse(`🔧 parseEventHandler: ENTRY - parsing event handler`);
+        debug.parse(`\ud83d\udd27 parseEventHandler: ENTRY - parsing event handler`);
         const eventNames = [];
         let firstOnceAlias = false;
         if (this.check('first') && !this.checkIsCommand() && this.current + 1 < this.tokens.length) {
@@ -11641,27 +11706,27 @@ class Parser {
             if (peek2Value && peek2Value !== 'of' && peek2Value !== 'in' && peek2Value !== 'from') {
                 this.advance();
                 firstOnceAlias = true;
-                debug.parse(`🔧 parseEventHandler: Parsed 'first' as .once alias`);
+                debug.parse(`\ud83d\udd27 parseEventHandler: Parsed 'first' as .once alias`);
             }
         }
         const event = this.parseEventNameWithNamespace("Expected event name after 'on'");
         eventNames.push(event);
-        debug.parse(`🔧 parseEventHandler: Parsed first event name: ${event}`);
+        debug.parse(`\ud83d\udd27 parseEventHandler: Parsed first event name: ${event}`);
         while (this.check('or')) {
             this.advance();
-            debug.parse(`🔧 parseEventHandler: Found 'or', parsing additional event name`);
+            debug.parse(`\ud83d\udd27 parseEventHandler: Found 'or', parsing additional event name`);
             const additionalEvent = this.parseEventNameWithNamespace("Expected event name after 'or'");
             eventNames.push(additionalEvent);
-            debug.parse(`🔧 parseEventHandler: Parsed additional event name: ${additionalEvent}`);
+            debug.parse(`\ud83d\udd27 parseEventHandler: Parsed additional event name: ${additionalEvent}`);
         }
-        debug.parse(`🔧 parseEventHandler: Total events parsed: ${eventNames.join(', ')}`);
+        debug.parse(`\ud83d\udd27 parseEventHandler: Total events parsed: ${eventNames.join(', ')}`);
         let customEventSource;
         if (this.registryIntegration) {
             const firstEvent = eventNames[0];
             if (this.registryIntegration.hasEventSource(firstEvent)) {
                 const source = this.registryIntegration.getEventSource(firstEvent);
                 customEventSource = source?.name;
-                debug.parse(`🔧 parseEventHandler: Detected custom event source '${customEventSource}' for event '${firstEvent}'`);
+                debug.parse(`\ud83d\udd27 parseEventHandler: Detected custom event source '${customEventSource}' for event '${firstEvent}'`);
             }
         }
         const eventParams = [];
@@ -11673,7 +11738,7 @@ class Parser {
                 } while (this.match(','));
             }
             this.consume(')', "Expected ')' after event parameters");
-            debug.parse(`🔧 parseEventHandler: Parsed event parameters: ${eventParams.join(', ')}`);
+            debug.parse(`\ud83d\udd27 parseEventHandler: Parsed event parameters: ${eventParams.join(', ')}`);
         }
         const modifiers = {};
         while (this.check('.')) {
@@ -11682,15 +11747,15 @@ class Parser {
             const modName = modToken.value.toLowerCase();
             if (modName === 'once') {
                 modifiers.once = true;
-                debug.parse(`🔧 parseEventHandler: Parsed modifier '.once'`);
+                debug.parse(`\ud83d\udd27 parseEventHandler: Parsed modifier '.once'`);
             }
             else if (modName === 'prevent') {
                 modifiers.prevent = true;
-                debug.parse(`🔧 parseEventHandler: Parsed modifier '.prevent'`);
+                debug.parse(`\ud83d\udd27 parseEventHandler: Parsed modifier '.prevent'`);
             }
             else if (modName === 'stop') {
                 modifiers.stop = true;
-                debug.parse(`🔧 parseEventHandler: Parsed modifier '.stop'`);
+                debug.parse(`\ud83d\udd27 parseEventHandler: Parsed modifier '.stop'`);
             }
             else if (modName === 'debounce' || modName === 'throttle') {
                 if (this.check('(')) {
@@ -11702,11 +11767,11 @@ class Parser {
                     }
                     if (modName === 'debounce') {
                         modifiers.debounce = delayMs;
-                        debug.parse(`🔧 parseEventHandler: Parsed modifier '.debounce(${delayMs})'`);
+                        debug.parse(`\ud83d\udd27 parseEventHandler: Parsed modifier '.debounce(${delayMs})'`);
                     }
                     else {
                         modifiers.throttle = delayMs;
-                        debug.parse(`🔧 parseEventHandler: Parsed modifier '.throttle(${delayMs})'`);
+                        debug.parse(`\ud83d\udd27 parseEventHandler: Parsed modifier '.throttle(${delayMs})'`);
                     }
                     this.consume(')', `Expected ')' after ${modName} delay`);
                 }
@@ -11715,7 +11780,7 @@ class Parser {
                 }
             }
             else {
-                debug.parse(`🔧 parseEventHandler: Warning - unknown modifier '.${modName}'`);
+                debug.parse(`\ud83d\udd27 parseEventHandler: Warning - unknown modifier '.${modName}'`);
             }
         }
         this.parseTemporalKeywordModifiers(modifiers);
@@ -11723,7 +11788,7 @@ class Parser {
             modifiers.once = true;
         }
         if (Object.keys(modifiers).length > 0) {
-            debug.parse(`🔧 parseEventHandler: Parsed modifiers:`, modifiers);
+            debug.parse(`\ud83d\udd27 parseEventHandler: Parsed modifiers:`, modifiers);
         }
         let condition;
         if (this.match('[')) {
@@ -11734,7 +11799,7 @@ class Parser {
         if (this.match('from')) {
             const targetToken = this.advance();
             target = targetToken.value;
-            debug.parse(`🔧 parseEventHandler: Parsed 'from' target: ${target} (kind: ${targetToken.kind})`);
+            debug.parse(`\ud83d\udd27 parseEventHandler: Parsed 'from' target: ${target} (kind: ${targetToken.kind})`);
             this.parseTemporalKeywordModifiers(modifiers);
         }
         let attributeName;
@@ -11746,32 +11811,36 @@ class Parser {
             else {
                 attributeName = attrToken.value;
             }
-            debug.parse(`🔧 parseEventHandler: Parsed attribute name: ${attributeName}`);
+            debug.parse(`\ud83d\udd27 parseEventHandler: Parsed attribute name: ${attributeName}`);
         }
         let watchTarget;
         if (this.match('in')) {
-            debug.parse(`🔧 parseEventHandler: Found 'in' keyword, parsing watch target`);
+            debug.parse(`\ud83d\udd27 parseEventHandler: Found 'in' keyword, parsing watch target`);
             watchTarget = this.parseExpression();
-            debug.parse(`🔧 parseEventHandler: Parsed watch target expression`);
+            debug.parse(`\ud83d\udd27 parseEventHandler: Parsed watch target expression`);
         }
         const commands = [];
-        debug.parse(`✅ parseEventHandler: About to parse commands, current token: ${this.isAtEnd() ? 'END' : this.peek().value}, isAtEnd: ${this.isAtEnd()}`);
+        debug.parse(`\u2705 parseEventHandler: About to parse commands, current token: ${this.isAtEnd() ? 'END' : this.peek().value}, isAtEnd: ${this.isAtEnd()}`);
         while (!this.isAtEnd()) {
-            debug.parse(`✅ parseEventHandler: Loop iteration, current token: ${this.peek().value}, kind: ${this.peek().kind}`);
+            debug.parse(`\u2705 parseEventHandler: Loop iteration, current token: ${this.peek().value}, kind: ${this.peek().kind}`);
             if (this.check('on')) {
-                debug.parse(`✅ parseEventHandler: Stopping command parsing, found next event handler 'on'`);
+                debug.parse(`\u2705 parseEventHandler: Stopping command parsing, found next event handler 'on'`);
                 break;
             }
             if (this.checkComment()) {
-                debug.parse(`✅ parseEventHandler: Skipping comment token: ${this.peek().value}`);
+                debug.parse(`\u2705 parseEventHandler: Skipping comment token: ${this.peek().value}`);
                 this.advance();
                 continue;
             }
             if (this.check('end')) {
-                debug.parse(`✅ parseEventHandler: Stopping command parsing, found 'end' keyword`);
+                debug.parse(`\u2705 parseEventHandler: Stopping command parsing, found 'end' keyword`);
                 this.advance();
                 break;
             }
+            if (this.check('catch') || this.check('finally')) {
+                debug.parse(`\u2705 parseEventHandler: Stopping command parsing, found '${this.peek().value}'`);
+                break;
+            }
             if (this.checkIsCommand()) {
                 const nextIsOpenParen = this.tokens[this.current + 1]?.value === '(';
                 const commandName = this.peek().value.toLowerCase();
@@ -11800,7 +11869,7 @@ class Parser {
                     const cmd = this.parseCommandWithErrorRecovery();
                     if (cmd) {
                         commands.push(cmd);
-                        debug.parse(`✅ parseEventHandler: Parsed command, next token: ${this.isAtEnd() ? 'END' : this.peek().value}`);
+                        debug.parse(`\u2705 parseEventHandler: Parsed command, next token: ${this.isAtEnd() ? 'END' : this.peek().value}`);
                     }
                 }
             }
@@ -11818,7 +11887,7 @@ class Parser {
                         expr = this.parseExpression();
                     }
                     catch (error) {
-                        debug.parse('⚠️ Expression parsing error, restoring error state:', error instanceof Error ? error.message : String(error));
+                        debug.parse('\u26a0\ufe0f Expression parsing error, restoring error state:', error instanceof Error ? error.message : String(error));
                         this.error = savedError;
                         break;
                     }
@@ -11865,7 +11934,9 @@ class Parser {
                 !this.check('then') &&
                 !this.check('and') &&
                 !this.check(',') &&
-                !this.check('on')) {
+                !this.check('on') &&
+                !this.check('catch') &&
+                !this.check('finally')) {
                 this.advance();
             }
             if (this.match('then', 'and', ',')) {
@@ -11878,12 +11949,24 @@ class Parser {
                 break;
             }
         }
+        let errorSymbol;
+        let errorHandler;
+        let finallyHandler;
+        if (!this.isAtEnd() && (this.check('catch') || this.check('finally'))) {
+            ({ errorSymbol, errorHandler, finallyHandler } = this.parseErrorAndFinallyBlocks());
+            if (this.check('end')) {
+                this.advance();
+            }
+        }
         const pos = this.getPosition();
         const node = {
             type: 'eventHandler',
             event: eventNames.length === 1 ? eventNames[0] : eventNames.join('|'),
             events: eventNames,
             commands,
+            ...(errorSymbol !== undefined && { errorSymbol }),
+            ...(errorHandler !== undefined && { errorHandler }),
+            ...(finallyHandler !== undefined && { finallyHandler }),
             ...(eventParams.length > 0 && { args: eventParams }),
             ...(condition && { condition }),
             ...(target && { target }),
@@ -11896,7 +11979,7 @@ class Parser {
             line: pos.line,
             column: pos.column,
         };
-        debug.parse(`🔧 parseEventHandler: Created node with events: ${eventNames.join(', ')}, attributeName: ${attributeName || 'none'}, watchTarget: ${watchTarget ? 'yes' : 'none'}`);
+        debug.parse(`\ud83d\udd27 parseEventHandler: Created node with events: ${eventNames.join(', ')}, attributeName: ${attributeName || 'none'}, watchTarget: ${watchTarget ? 'yes' : 'none'}`);
         return node;
     }
     parseBehaviorDefinition() {
@@ -11961,11 +12044,33 @@ class Parser {
                         }
                     }
                 }
-                const handlerCommands = this.parseCommandListUntilEnd();
+                const { commands: handlerCommands, terminator } = this.parseCommandListUntilTerminator([
+                    'catch',
+                    'finally',
+                ]);
+                let handlerErrorSymbol;
+                let handlerErrorHandler;
+                let handlerFinallyHandler;
+                if (terminator === 'catch' || terminator === 'finally') {
+                    ({
+                        errorSymbol: handlerErrorSymbol,
+                        errorHandler: handlerErrorHandler,
+                        finallyHandler: handlerFinallyHandler,
+                    } = this.parseErrorAndFinallyBlocks());
+                }
+                if (this.check('end')) {
+                    this.advance();
+                }
+                else {
+                    throw new Error('Expected "end" to close behavior event handler');
+                }
                 const handlerNode = {
                     type: 'eventHandler',
                     event: eventName,
                     commands: handlerCommands,
+                    ...(handlerErrorSymbol !== undefined && { errorSymbol: handlerErrorSymbol }),
+                    ...(handlerErrorHandler !== undefined && { errorHandler: handlerErrorHandler }),
+                    ...(handlerFinallyHandler !== undefined && { finallyHandler: handlerFinallyHandler }),
                     ...(eventSource !== undefined && { target: eventSource }),
                     ...(eventArgs.length > 0 && { args: eventArgs }),
                     start: handlerPos.start,
@@ -12020,7 +12125,7 @@ class Parser {
                         this.error.message.includes('unclosed parenthes') ||
                         this.error.message.includes('Unclosed parenthes');
                     if (!isCriticalError) {
-                        debug.parse('⚠️  parseCommandSequence: Command parsing added non-critical error, restoring error state. Error was:', this.error.message);
+                        debug.parse('\u26a0\ufe0f  parseCommandSequence: Command parsing added non-critical error, restoring error state. Error was:', this.error.message);
                         this.error = savedError;
                     }
                 }
@@ -12030,11 +12135,11 @@ class Parser {
                     !this.isCommand(this.peek().value) &&
                     !this.check('then') &&
                     !this.check('on')) {
-                    debug.parse('⚠️  parseCommandSequence: Skipping unexpected token:', this.peek().value);
+                    debug.parse('\u26a0\ufe0f  parseCommandSequence: Skipping unexpected token:', this.peek().value);
                     this.advance();
                 }
                 if (this.check('on')) {
-                    debug.parse('✅ parseCommandSequence: Found "on" token, stopping command sequence to allow event handler parsing');
+                    debug.parse('\u2705 parseCommandSequence: Found "on" token, stopping command sequence to allow event handler parsing');
                     break;
                 }
                 if (this.match('then')) {
@@ -12092,6 +12197,9 @@ class Parser {
                 this.advance();
                 const cmd = this.parseCommand();
                 commands.push(cmd);
+                if (this.match('then', 'and', ',')) {
+                    continue;
+                }
             }
             else {
                 break;
@@ -12478,7 +12586,7 @@ class Parser {
         if (!this.check(')') && callee.type === 'identifier') {
             const funcName = callee.name;
             if (CommandClassification.isCSSFunction(funcName)) {
-                debug.parse(`💡 Tip: CSS functions like ${funcName}() should be quoted for clean parsing. ` +
+                debug.parse(`\ud83d\udca1 Tip: CSS functions like ${funcName}() should be quoted for clean parsing. ` +
                     `Use '${funcName}(...)' or \`${funcName}(...)\` instead.`);
             }
         }
@@ -12780,7 +12888,7 @@ class Parser {
             if (this.checkIsCommand() || (this.isCommand(token.value) && !this.isKeyword(token.value))) {
                 return;
             }
-            debug.parse('⚠️  synchronize: Skipping token:', token.value);
+            debug.parse('\u26a0\ufe0f  synchronize: Skipping token:', token.value);
             this.advance();
         }
     }
@@ -16767,8 +16875,15 @@ let FetchCommand = (() => {
         }
         async parseURL(arg, evaluator, context) {
             const v = await evaluator.evaluate(arg, context);
-            if (typeof v !== 'string' || !v)
+            if (typeof v !== 'string' || !v) {
+                const node = arg;
+                if ((v === undefined || v === null) && node?.type === 'identifier' && node.name) {
+                    throw new Error(`fetch: URL expression "${node.name}" evaluated to ${String(v)} \u2014 ` +
+                        `check the variable is set, or quote it if you meant a literal URL ` +
+                        `(fetch 'https://example.com/path')`);
+                }
                 throw new Error('fetch: URL must be a non-empty string');
+            }
             return v;
         }
         parseResponseType(asNode) {
@@ -16987,7 +17102,7 @@ let SetCommand = (() => {
             if (typeof firstValue !== 'string') {
                 const isMember = firstArg?.type === 'memberExpression' || firstArg?.type === 'propertyAccess';
                 const hint = isMember
-                    ? ` (a property chain evaluated to ${firstValue === null ? 'null' : typeof firstValue} — check that all intermediate objects exist)`
+                    ? ` (a property chain evaluated to ${firstValue === null ? 'null' : typeof firstValue} \u2014 check that all intermediate objects exist)`
                     : '';
                 throw new Error(`set command target must be a string or object literal${hint}`);
             }
@@ -18065,7 +18180,7 @@ let BeepCommand = (() => {
                 return { expressionCount: 0, debugged: true, outputs: [] };
             }
             const outputs = [];
-            console.group('🔔 beep! Debug Output');
+            console.group('\ud83d\udd14 beep! Debug Output');
             for (const expression of expressions) {
                 const output = this.debugExpression(expression);
                 outputs.push(output);
@@ -18078,7 +18193,7 @@ let BeepCommand = (() => {
             return { expressionCount: expressions.length, debugged: true, outputs };
         }
         debugContext(context) {
-            console.group('🔔 beep! Context Debug');
+            console.group('\ud83d\udd14 beep! Context Debug');
             console.log('me:', context.me);
             console.log('it:', context.it);
             console.log('you:', context.you);