zexus 1.8.1 → 1.8.2

package/bin/zexus

@@ -1,2 +1,12 @@
-#!/usr/bin/env bash
-python3 -m zexus "$@"
+#!/usr/bin/env node
+const { spawn } = require('child_process');
+const proc = spawn('python3', ['-m', 'zexus', ...process.argv.slice(2)], { stdio: 'inherit' });
+proc.on('error', (err) => {
+  if (err.code === 'ENOENT') {
+    console.error('Error: python3 not found. Please install Python 3.8+ to use Zexus.');
+    process.exit(1);
+  }
+  console.error('Error:', err.message);
+  process.exit(1);
+});
+proc.on('close', (code) => process.exit(code ?? 1));

package/bin/zpics

@@ -1,2 +1,12 @@
-#!/usr/bin/env bash
-python3 -m zexus.pics "$@"
+#!/usr/bin/env node
+const { spawn } = require('child_process');
+const proc = spawn('python3', ['-m', 'zexus.pics', ...process.argv.slice(2)], { stdio: 'inherit' });
+proc.on('error', (err) => {
+  if (err.code === 'ENOENT') {
+    console.error('Error: python3 not found. Please install Python 3.8+ to use Zexus.');
+    process.exit(1);
+  }
+  console.error('Error:', err.message);
+  process.exit(1);
+});
+proc.on('close', (code) => process.exit(code ?? 1));

package/bin/zpm

@@ -1,2 +1,12 @@
-#!/usr/bin/env bash
-python3 -m zexus.zpm "$@"
+#!/usr/bin/env node
+const { spawn } = require('child_process');
+const proc = spawn('python3', ['-m', 'zexus.zpm', ...process.argv.slice(2)], { stdio: 'inherit' });
+proc.on('error', (err) => {
+  if (err.code === 'ENOENT') {
+    console.error('Error: python3 not found. Please install Python 3.8+ to use Zexus.');
+    process.exit(1);
+  }
+  console.error('Error:', err.message);
+  process.exit(1);
+});
+proc.on('close', (code) => process.exit(code ?? 1));

package/bin/zx

@@ -1,2 +1,12 @@
-#!/usr/bin/env bash
-python3 -m zexus "$@"
+#!/usr/bin/env node
+const { spawn } = require('child_process');
+const proc = spawn('python3', ['-m', 'zexus', ...process.argv.slice(2)], { stdio: 'inherit' });
+proc.on('error', (err) => {
+  if (err.code === 'ENOENT') {
+    console.error('Error: python3 not found. Please install Python 3.8+ to use Zexus.');
+    process.exit(1);
+  }
+  console.error('Error:', err.message);
+  process.exit(1);
+});
+proc.on('close', (code) => process.exit(code ?? 1));

package/bin/zx-deploy

@@ -1,2 +1,12 @@
-#!/usr/bin/env bash
-python3 -m zexus.deploy "$@"
+#!/usr/bin/env node
+const { spawn } = require('child_process');
+const proc = spawn('python3', ['-m', 'zexus.deploy', ...process.argv.slice(2)], { stdio: 'inherit' });
+proc.on('error', (err) => {
+  if (err.code === 'ENOENT') {
+    console.error('Error: python3 not found. Please install Python 3.8+ to use Zexus.');
+    process.exit(1);
+  }
+  console.error('Error:', err.message);
+  process.exit(1);
+});
+proc.on('close', (code) => process.exit(code ?? 1));

package/bin/zx-dev

@@ -1,2 +1,12 @@
-#!/usr/bin/env bash
-python3 -m zexus.dev "$@"
+#!/usr/bin/env node
+const { spawn } = require('child_process');
+const proc = spawn('python3', ['-m', 'zexus.dev', ...process.argv.slice(2)], { stdio: 'inherit' });
+proc.on('error', (err) => {
+  if (err.code === 'ENOENT') {
+    console.error('Error: python3 not found. Please install Python 3.8+ to use Zexus.');
+    process.exit(1);
+  }
+  console.error('Error:', err.message);
+  process.exit(1);
+});
+proc.on('close', (code) => process.exit(code ?? 1));

package/bin/zx-run

@@ -1,2 +1,12 @@
-#!/usr/bin/env bash
-python3 -m zexus.runner "$@"
+#!/usr/bin/env node
+const { spawn } = require('child_process');
+const proc = spawn('python3', ['-m', 'zexus.runner', ...process.argv.slice(2)], { stdio: 'inherit' });
+proc.on('error', (err) => {
+  if (err.code === 'ENOENT') {
+    console.error('Error: python3 not found. Please install Python 3.8+ to use Zexus.');
+    process.exit(1);
+  }
+  console.error('Error:', err.message);
+  process.exit(1);
+});
+proc.on('close', (code) => process.exit(code ?? 1));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zexus",
-  "version": "1.8.1",
+  "version": "1.8.2",
   "description": "A modern, security-first programming language with blockchain support",
   "main": "index.js",
   "bin": {

package/scripts/postinstall.js

@@ -3,74 +3,225 @@
 const { execSync } = require('child_process');
 const fs = require('fs');
 const path = require('path');
+const os = require('os');
 
 console.log('\n🚀 Installing Zexus Programming Language...\n');
 
-// Check if Python is available
-try {
-  const pythonVersion = execSync('python3 --version', { encoding: 'utf-8' });
-  console.log(`✓ Found ${pythonVersion.trim()}`);
-} catch (error) {
-  console.error('❌ Python 3.8+ is required but not found.');
-  console.error('Please install Python 3.8 or higher: https://www.python.org/downloads/');
-  process.exit(1);
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function hasCommand(cmd) {
+  try {
+    execSync(`${cmd} --version`, { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
 }
 
-// Check Python version
-try {
-  const versionCheck = execSync('python3 -c "import sys; sys.exit(0 if sys.version_info >= (3, 8) else 1)"');
-  console.log('✓ Python version is 3.8 or higher');
-} catch (error) {
-  console.error('❌ Python 3.8 or higher is required.');
+function run(cmd, opts = {}) {
+  return execSync(cmd, { encoding: 'utf-8', stdio: 'inherit', ...opts });
+}
+
+function runQuiet(cmd) {
+  return execSync(cmd, { encoding: 'utf-8', stdio: 'pipe' });
+}
+
+const isWin = os.platform() === 'win32';
+const pip = isWin ? 'pip' : 'pip3';
+const python = isWin ? 'python' : 'python3';
+
+// ---------------------------------------------------------------------------
+// 1. Python — check or install
+// ---------------------------------------------------------------------------
+
+let pythonAvailable = false;
+
+if (hasCommand(python)) {
+  try {
+    const ver = runQuiet(`${python} --version`).trim();
+    console.log(`✓ Found ${ver}`);
+    // Verify >= 3.8
+    runQuiet(`${python} -c "import sys; sys.exit(0 if sys.version_info >= (3, 8) else 1)"`);
+    console.log('✓ Python version is 3.8 or higher');
+    pythonAvailable = true;
+  } catch {
+    console.error('❌ Python was found but version is below 3.8.');
+    console.error('   Please upgrade to Python 3.8+: https://www.python.org/downloads/');
+  }
+} else {
+  console.warn('⚠️  python3 not found on PATH.');
+  // Attempt auto-install on common platforms
+  if (os.platform() === 'linux') {
+    console.log('   Attempting to install python3 via apt...');
+    try {
+      run('sudo apt-get update -qq && sudo apt-get install -y -qq python3 python3-pip python3-venv');
+      pythonAvailable = true;
+      console.log('✓ Python 3 installed via apt');
+    } catch {
+      console.warn('   Could not auto-install Python. Please install manually:');
+      console.warn('   https://www.python.org/downloads/');
+    }
+  } else if (os.platform() === 'darwin') {
+    if (hasCommand('brew')) {
+      console.log('   Attempting to install python3 via Homebrew...');
+      try {
+        run('brew install python@3');
+        pythonAvailable = true;
+        console.log('✓ Python 3 installed via Homebrew');
+      } catch {
+        console.warn('   Could not auto-install Python. Please install manually:');
+        console.warn('   https://www.python.org/downloads/');
+      }
+    } else {
+      console.warn('   Please install Python 3.8+: https://www.python.org/downloads/');
+    }
+  } else {
+    console.warn('   Please install Python 3.8+: https://www.python.org/downloads/');
+  }
+}
+
+if (!pythonAvailable) {
+  console.error('\n❌ Python 3.8+ is required but could not be found or installed.');
+  console.error('   Install it from: https://www.python.org/downloads/');
+  console.error('   Then re-run: npm rebuild zexus');
   process.exit(1);
 }
 
-// Install Zexus Python package
+// ---------------------------------------------------------------------------
+// 2. pip — ensure available
+// ---------------------------------------------------------------------------
+
+if (!hasCommand(pip) && !hasCommand('pip')) {
+  console.log('   pip not found — bootstrapping...');
+  try {
+    run(`${python} -m ensurepip --upgrade`);
+  } catch {
+    try {
+      run(`${python} -m pip install --upgrade pip`);
+    } catch {
+      console.warn('⚠️  Could not bootstrap pip. Python package install may fail.');
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// 3. Install Zexus Python package
+// ---------------------------------------------------------------------------
+
 console.log('\n📦 Installing Zexus Python package...');
+
+// Check if zexus is already installed and up-to-date
+let zexusInstalled = false;
 try {
-  // Install with "full" extras so blockchain/network/security features work out of the box.
-  // Use --user to avoid permission issues on global Python installs.
-  execSync('pip3 install --user "zexus[full]"', { stdio: 'inherit' });
-  console.log('\n✓ Zexus Python package installed successfully');
-} catch (error) {
-  console.error('\n❌ Failed to install Zexus Python package.');
-  console.error('Please run manually: pip3 install --user "zexus[full]"');
-  process.exit(1);
+  runQuiet(`${python} -c "import zexus"`);
+  zexusInstalled = true;
+  console.log('✓ Zexus Python package already installed');
+} catch {
+  // Not installed yet
 }
 
-// Best-effort: build/install Rust VM extension from bundled sources when available.
-// This requires a Rust toolchain and may fail on systems without build tooling.
-function hasCommand(cmd) {
+if (!zexusInstalled) {
   try {
-    execSync(`${cmd} --version`, { stdio: 'ignore' });
-    return true;
+    run(`${python} -m pip install --user "zexus[full]"`);
+    console.log('✓ Zexus Python package installed successfully');
   } catch {
-    return false;
+    // Retry without --user (some environments like venvs don't need it)
+    try {
+      run(`${python} -m pip install "zexus[full]"`);
+      console.log('✓ Zexus Python package installed successfully');
+    } catch {
+      console.error('❌ Failed to install Zexus Python package.');
+      console.error(`   Please run manually: ${python} -m pip install "zexus[full]"`);
+      // Don't exit — commands that don't need Python may still work
+    }
   }
 }
 
+// ---------------------------------------------------------------------------
+// 4. Rust toolchain — check or install, then build rust_core
+// ---------------------------------------------------------------------------
+
 const pkgRoot = path.resolve(__dirname, '..');
 const cargoToml = path.join(pkgRoot, 'rust_core', 'Cargo.toml');
 
-if (fs.existsSync(cargoToml) && hasCommand('cargo')) {
-  console.log('\n🦀 Rust toolchain detected — attempting to build zexus_core...');
-  try {
-    execSync('python3 -m pip install --user --upgrade maturin', { stdio: 'inherit' });
-    execSync(`python3 -m maturin develop -m "${cargoToml}" --release`, { stdio: 'inherit' });
-    execSync('python3 -c "import zexus_core; print(\"zexus_core OK\", zexus_core.version())"', { stdio: 'inherit' });
-    console.log('✓ Rust VM extension built and installed');
-  } catch (error) {
-    console.warn('\n⚠️  Rust VM build failed; continuing with pure-Python VM.');
-    console.warn('   To retry manually (from source repo):');
-    console.warn('     pip install maturin && maturin develop -m rust_core/Cargo.toml --release');
+if (fs.existsSync(cargoToml)) {
+  let cargoReady = hasCommand('cargo');
+
+  if (!cargoReady) {
+    console.log('\n🦀 Rust toolchain (cargo) not found.');
+    console.log('   Attempting to install Rust via rustup...');
+    try {
+      if (isWin) {
+        // On Windows, download and run rustup-init
+        console.log('   Please install Rust manually: https://rustup.rs');
+      } else {
+        // Unix: install rustup non-interactively
+        run('curl --proto "=https" --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y');
+        // Source the cargo env so it's available in this session
+        const cargoEnv = path.join(os.homedir(), '.cargo', 'env');
+        if (fs.existsSync(cargoEnv)) {
+          // Read the cargo bin path and add to PATH for child processes
+          const cargoBin = path.join(os.homedir(), '.cargo', 'bin');
+          process.env.PATH = `${cargoBin}${path.delimiter}${process.env.PATH}`;
+        }
+        cargoReady = hasCommand('cargo');
+        if (cargoReady) {
+          console.log('✓ Rust toolchain installed via rustup');
+        }
+      }
+    } catch (err) {
+      console.warn('⚠️  Could not auto-install Rust. Continuing with pure-Python VM.');
+      console.warn('   To install manually: https://rustup.rs');
+    }
+  } else {
+    console.log('\n✓ Rust toolchain detected');
+  }
+
+  if (cargoReady) {
+    // Check if zexus_core is already importable
+    let rustVmInstalled = false;
+    try {
+      runQuiet(`${python} -c "import zexus_core"`);
+      rustVmInstalled = true;
+      console.log('✓ Rust VM extension (zexus_core) already installed');
+    } catch {
+      // Need to build
+    }
+
+    if (!rustVmInstalled) {
+      console.log('🔨 Building Rust VM extension (zexus_core)...');
+      try {
+        // Ensure maturin is available
+        try {
+          runQuiet(`${python} -m maturin --version`);
+        } catch {
+          console.log('   Installing maturin build tool...');
+          run(`${python} -m pip install --user --upgrade maturin`);
+        }
+        run(`${python} -m maturin develop -m "${cargoToml}" --release`);
+        runQuiet(`${python} -c "import zexus_core"`);
+        console.log('✓ Rust VM extension built and installed');
+      } catch (error) {
+        console.warn('\n⚠️  Rust VM build failed; continuing with pure-Python VM.');
+        console.warn('   To retry manually:');
+        console.warn(`     ${python} -m pip install maturin && ${python} -m maturin develop -m rust_core/Cargo.toml --release`);
+      }
+    }
   }
 } else {
-  console.log('\nℹ️  Skipping Rust VM build (cargo not found or rust_core not bundled).');
+  console.log('\nℹ️  rust_core/Cargo.toml not bundled; skipping Rust VM build.');
 }
 
+// ---------------------------------------------------------------------------
+// Done
+// ---------------------------------------------------------------------------
+
 console.log('\n✅ Zexus installed successfully!\n');
 console.log('Get started:');
 console.log('  zexus --help       # Show help');
 console.log('  zx --version       # Check version');
+console.log('  zx run file.zx     # Run a Zexus file');
 console.log('  zexus examples/    # Explore examples\n');
 console.log('Documentation: https://github.com/Zaidux/zexus-interpreter\n');

package/src/zexus/__init__.py

@@ -4,7 +4,7 @@ Zexus Programming Language
 A declarative, intent-based programming language for modern applications.
 """
 
-__version__ = "1.8.1"
+__version__ = "1.8.2"
 __author__ = "Ziver Labs"
 __email__ = "ziverofficial567@gmail.com"
 

package/src/zexus/cli/main.py

@@ -156,7 +156,7 @@ def show_all_commands():
     console.print("\n[bold green]💡 Tip:[/bold green] Use 'zx <command> --help' for detailed command options\n")
 
 @click.group(invoke_without_command=True)
-@click.version_option(version="1.8.1", prog_name="Zexus")
+@click.version_option(version="1.8.2", prog_name="Zexus")
 @click.option('--syntax-style', type=click.Choice(['universal', 'tolerable', 'auto']),
               default='auto', help='Syntax style to use (universal=strict, tolerable=flexible)')
 @click.option('--advanced-parsing', is_flag=True, default=True,

package/src/zexus/cli/zpm.py

@@ -18,7 +18,7 @@ console = Console()
 
 
 @click.group()
-@click.version_option(version="1.8.1", prog_name="ZPM")
+@click.version_option(version="1.8.2", prog_name="ZPM")
 def cli():
     """ZPM - Zexus Package Manager
     

package/src/zexus/parser/parser.py

@@ -362,6 +362,15 @@ class UltimateParser:
                         if match_brace_depth == 0:
                             in_match_brace = False
                 elif t.type == LAMBDA and getattr(t, 'literal', None) == '=>':
+                    # Exclude watch => patterns — those are reactive watchers, not lambdas
+                    if idx > 0 and all_tokens[idx - 1].type == IDENT:
+                        # Check if this is a watch statement: watch <expr> =>
+                        # Walk back past identifiers and dots (e.g. watch order.status =>)
+                        watch_idx = idx - 2
+                        while watch_idx >= 0 and all_tokens[watch_idx].type in (IDENT, DOT):
+                            watch_idx -= 1
+                        if watch_idx >= 0 and getattr(all_tokens[watch_idx], 'type', None) == WATCH:
+                            continue  # Skip watch arrows
                     has_non_match_arrow = True
                     break
             if has_non_match_arrow:
@@ -4606,8 +4615,16 @@ class UltimateParser:
         
         return UsingStatement(resource_name=resource_name, resource_expr=resource_expr, body=body)
 
+    def parse_type_expression(self):
+        """Parse a simple type expression (identifier)."""
+        if self.cur_token_is(IDENT):
+            type_node = Identifier(self.cur_token.literal)
+            self.next_token()
+            return type_node
+        return None
+
     def parse_channel_statement(self):
-        """Parse channel declaration: channel<type> name; or channel<type> name = expr;"""
+        """Parse channel declaration: channel<type>[capacity] name"""
         token = self.cur_token
         self.next_token()  # consume CHANNEL
         
@@ -4625,25 +4642,33 @@ class UltimateParser:
         
         self.next_token()
         
+        # Optional capacity in brackets: [10]
+        capacity = None
+        if self.cur_token_is(LBRACKET):
+            self.next_token()
+            capacity = self.parse_expression(LOWEST)
+            if not self.cur_token_is(RBRACKET):
+                self.errors.append(f"Line {token.line}:{token.column} - Expected ']' after channel capacity")
+                return None
+            self.next_token()
+        
         # Parse channel name
         if not self.cur_token_is(IDENT):
             self.errors.append(f"Line {token.line}:{token.column} - Expected channel name")
             return None
         
-        name = self.cur_token.literal
+        name = Identifier(self.cur_token.literal)
         self.next_token()
         
-        # Optional capacity specification
-        capacity = None
-        if self.cur_token_is(ASSIGN):
+        # Optional capacity via assignment: = expr
+        if capacity is None and self.cur_token_is(ASSIGN):
             self.next_token()
             capacity = self.parse_expression(LOWEST)
         
-        if not self.cur_token_is(SEMICOLON):
-            self.errors.append(f"Line {token.line}:{token.column} - Expected ';' after channel declaration")
-            return None
+        # Semicolons are optional in modern Zexus
+        if self.cur_token_is(SEMICOLON):
+            self.next_token()
         
-        self.next_token()
         return ChannelStatement(name=name, element_type=element_type, capacity=capacity)
 
     def parse_send_statement(self):

package/src/zexus/parser/strategy_context.py

@@ -16,7 +16,8 @@ STATEMENT_STARTERS = {
     SIMD, DEFER, PATTERN, ENUM, STREAM, WATCH, LOG, CAPABILITY, GRANT,
     REVOKE, VALIDATE, SANITIZE, IMMUTABLE, INTERFACE, TYPE_ALIAS, MODULE,
     PACKAGE, USING, MIDDLEWARE, AUTH, THROTTLE, CACHE, REQUIRE,
-    EMIT, PROTOCOL, SEAL
+    EMIT, PROTOCOL, SEAL,
+    CHANNEL, SEND, RECEIVE, ATOMIC, ASYNC,
 }
 
 _MEANINGFUL_TOKEN_TYPES = {
@@ -1267,7 +1268,8 @@ class ContextStackParser:
             EXPORT, USE, DEBUG, ENTITY, CONTRACT, AUDIT, RESTRICT, SANDBOX, TRAIL, NATIVE, GC, INLINE,
             BUFFER, SIMD, DEFER, PATTERN, ENUM, STREAM, WATCH, CAPABILITY, GRANT,
             REVOKE, VALIDATE, SANITIZE, IMMUTABLE, INTERFACE, TYPE_ALIAS, MODULE,
-            PACKAGE, USING
+            PACKAGE, USING,
+            CHANNEL, SEND, RECEIVE, ATOMIC, ASYNC,
         }
         j = assign_idx + 1
         nesting_depth = 0
@@ -3983,6 +3985,35 @@ class ContextStackParser:
                 i = j
                 continue
 
+            elif token.type == CHANNEL:
+                # Parse CHANNEL declaration: channel<type>[capacity] name
+                j = i + 1
+                channel_tokens = [token]
+                # Collect until we hit a statement starter or semicolon at nesting 0
+                nesting = 0
+                while j < len(tokens):
+                    tj = tokens[j]
+                    if tj.type in (LBRACKET, LT):
+                        nesting += 1
+                    elif tj.type in (RBRACKET, GT):
+                        nesting -= 1
+                    elif nesting == 0 and tj.type == SEMICOLON:
+                        j += 1  # skip semicolon
+                        break
+                    elif nesting == 0 and tj.type in statement_starters and len(channel_tokens) > 1:
+                        break
+                    channel_tokens.append(tj)
+                    j += 1
+
+                # Use the context handler to parse the channel tokens
+                block_info = {'tokens': channel_tokens}
+                stmt = self._parse_channel_statement(block_info, tokens)
+                if stmt:
+                    statements.append(stmt)
+
+                i = j
+                continue
+
             elif token.type == ATOMIC:
                 # Parse ATOMIC statement: atomic { statements }
                 j = i + 1
@@ -4015,6 +4046,48 @@ class ContextStackParser:
                 continue
 
             elif token.type == ASYNC:
+                # Check if this is "async action" — treat as action with async modifier
+                if i + 1 < len(tokens) and tokens[i + 1].type == ACTION:
+                    # Collect entire async action declaration including brace body
+                    j = i + 1  # skip to ACTION token
+                    stmt_tokens = [tokens[j]]  # Start with ACTION token
+                    j += 1
+                    brace_nest = 0
+                    paren_nest = 0
+                    while j < len(tokens):
+                        tj = tokens[j]
+                        stmt_tokens.append(tj)
+                        if tj.type == LPAREN:
+                            paren_nest += 1
+                        elif tj.type == RPAREN:
+                            if paren_nest > 0:
+                                paren_nest -= 1
+                        elif tj.type == LBRACE:
+                            brace_nest += 1
+                        elif tj.type == RBRACE:
+                            brace_nest -= 1
+                            if brace_nest == 0:
+                                j += 1
+                                break
+                        j += 1
+
+                    # Parse as action statement and set is_async flag
+                    block_info = {'tokens': stmt_tokens}
+                    stmt = self._parse_action_statement(block_info, tokens)
+                    if stmt:
+                        stmt.is_async = True
+                        try:
+                            existing_modifiers = list(getattr(stmt, 'modifiers', []) or [])
+                            if 'async' not in existing_modifiers:
+                                existing_modifiers.append('async')
+                            stmt.modifiers = existing_modifiers
+                        except Exception:
+                            stmt.modifiers = ['async']
+                        statements.append(stmt)
+
+                    i = j
+                    continue
+
                 # Parse ASYNC expression: async <expression>
                 j = i + 1
                 
@@ -6157,6 +6230,22 @@ class ContextStackParser:
         # If this is "async function", let _parse_function_statement_context handle it
         if len(tokens) > 1 and tokens[1].type == FUNCTION:
             return self._parse_function_statement_context(block_info, all_tokens)
+
+        # If this is "async action", let _parse_action_statement handle it with async flag
+        if len(tokens) > 1 and tokens[1].type == ACTION:
+            action_tokens = tokens[1:]  # Strip ASYNC
+            action_block = {'tokens': action_tokens}
+            stmt = self._parse_action_statement(action_block, all_tokens)
+            if stmt:
+                stmt.is_async = True
+                try:
+                    existing_modifiers = list(getattr(stmt, 'modifiers', []) or [])
+                    if 'async' not in existing_modifiers:
+                        existing_modifiers.append('async')
+                    stmt.modifiers = existing_modifiers
+                except Exception:
+                    stmt.modifiers = ['async']
+            return stmt
         
         # The tokens are [ASYNC, ...expression tokens...]
         # We can just call parse_async_expression from the main parser!