@hyperfixi/core 2.9.0 → 2.9.1

package/dist/registry/index.mjs

@@ -31,39 +31,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);
     },
 };
 
@@ -4046,6 +4046,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 === ']' ||
@@ -5770,9 +5771,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__',
@@ -5783,7 +5784,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 = {
@@ -5794,7 +5795,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;
 }
 
@@ -6183,37 +6184,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.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.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 {
@@ -7314,16 +7315,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'])) {
@@ -7482,6 +7473,16 @@ function isFetchURLTerminator(ctx) {
     return (['as', 'with', '{', 'then', 'end', 'else', 'otherwise', ')'].includes(val) ||
         isCommandBoundary(ctx));
 }
+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 parseBareURLPath(ctx, isTerminator = isFetchURLTerminator) {
     const startPos = ctx.savePosition();
     let path = '';
@@ -7503,7 +7504,7 @@ function parseBareURLPath(ctx, isTerminator = isFetchURLTerminator) {
 function parseFetchCommand(ctx, commandToken) {
     const modifiers = {};
     let url = null;
-    if (!ctx.isAtEnd() && ctx.check('/')) {
+    if (!ctx.isAtEnd() && isNakedURLStart(ctx)) {
         url = parseBareURLPath(ctx);
     }
     if (!url) {
@@ -8069,26 +8070,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,
@@ -8097,11 +8098,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,
@@ -8496,41 +8497,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() &&
@@ -8538,19 +8539,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;
             }
         }
@@ -8564,18 +8565,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;
@@ -9248,6 +9249,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')) {
@@ -9262,19 +9280,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) {
@@ -9419,13 +9428,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;
         }
@@ -9442,12 +9451,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}`);
@@ -9458,7 +9467,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) {
@@ -9467,27 +9476,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 = [];
@@ -9499,7 +9508,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('.')) {
@@ -9508,15 +9517,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('(')) {
@@ -9528,11 +9537,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`);
                 }
@@ -9541,7 +9550,7 @@ class Parser {
                 }
             }
             else {
-                debug.parse(`🔧 parseEventHandler: Warning - unknown modifier '.${modName}'`);
+                debug.parse(`\ud83d\udd27 parseEventHandler: Warning - unknown modifier '.${modName}'`);
             }
         }
         this.parseTemporalKeywordModifiers(modifiers);
@@ -9549,7 +9558,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('[')) {
@@ -9560,7 +9569,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;
@@ -9572,32 +9581,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();
@@ -9626,7 +9639,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}`);
                     }
                 }
             }
@@ -9644,7 +9657,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;
                     }
@@ -9691,7 +9704,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', ',')) {
@@ -9704,12 +9719,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 }),
@@ -9722,7 +9749,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() {
@@ -9787,11 +9814,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,
@@ -9846,7 +9895,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;
                     }
                 }
@@ -9856,11 +9905,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')) {
@@ -10304,7 +10353,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.`);
             }
         }
@@ -10606,7 +10655,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();
         }
     }