feat(bash): arithmetic exponentiation, base literals, mapfile builtin

- Arithmetic ** (power) operator with correct precedence over *
- Base#value literals (16#ff, 2#1010, 8#77) and 0x/077 prefixes
- Unary operators: !, ~, - in arithmetic expressions
- mapfile/readarray builtin with -t flag and custom array name
- expand_arithmetic_vars tracks numeric literal context to avoid
  expanding hex digits as variable names
- 13 new spec tests (10 arithmetic, 3 mapfile)

https://claude.ai/code/session_012rzB3FRw7yoQWCG1mxyW7J

Author: claude

crates/bashkit/src/interpreter/mod.rs

@@ -2475,6 +2475,11 @@ impl Interpreter {
             return self.execute_getopts(&args, &command.redirects).await;
         }
 
+        // Handle `mapfile`/`readarray` - needs direct access to arrays
+        if name == "mapfile" || name == "readarray" {
+            return self.execute_mapfile(&args, stdin.as_deref()).await;
+        }
+
         // Check for builtins
         if let Some(builtin) = self.builtins.get(name) {
             let ctx = builtins::Context {
@@ -2854,6 +2859,53 @@ impl Interpreter {
 
     /// Execute the `getopts` builtin (POSIX option parsing).
     ///
+    /// Execute mapfile/readarray builtin — reads lines into an indexed array.
+    /// Handled inline because it needs direct access to self.arrays.
+    async fn execute_mapfile(
+        &mut self,
+        args: &[String],
+        stdin_data: Option<&str>,
+    ) -> Result<ExecResult> {
+        let mut trim_trailing = false; // -t: strip trailing newlines
+        let mut array_name = "MAPFILE".to_string();
+        let mut positional = Vec::new();
+
+        for arg in args {
+            match arg.as_str() {
+                "-t" => trim_trailing = true,
+                a if a.starts_with('-') => {} // skip unknown flags
+                _ => positional.push(arg.clone()),
+            }
+        }
+
+        if let Some(name) = positional.first() {
+            array_name = name.clone();
+        }
+
+        let input = stdin_data.unwrap_or("");
+
+        // Clear existing array
+        self.arrays.remove(&array_name);
+
+        // Split into lines and populate array
+        if !input.is_empty() {
+            let mut arr = HashMap::new();
+            for (idx, line) in input.lines().enumerate() {
+                let value = if trim_trailing {
+                    line.to_string()
+                } else {
+                    format!("{}\n", line)
+                };
+                arr.insert(idx, value);
+            }
+            if !arr.is_empty() {
+                self.arrays.insert(array_name, arr);
+            }
+        }
+
+        Ok(ExecResult::ok(String::new()))
+    }
+
     /// Usage: `getopts optstring name [args...]`
     ///
     /// Parses options from positional params (or `args`).
@@ -4416,9 +4468,12 @@ impl Interpreter {
     fn expand_arithmetic_vars(&self, expr: &str) -> String {
         let mut result = String::new();
         let mut chars = expr.chars().peekable();
+        // Track whether we're in a numeric literal context (after # or 0x)
+        let mut in_numeric_literal = false;
 
         while let Some(ch) = chars.next() {
             if ch == '$' {
+                in_numeric_literal = false;
                 // Handle $var syntax (common in arithmetic)
                 let mut name = String::new();
                 while let Some(&c) = chars.peek() {
@@ -4438,7 +4493,26 @@ impl Interpreter {
                 } else {
                     result.push(ch);
                 }
+            } else if ch == '#' {
+                // base#value syntax: digits before # are base, chars after are literal digits
+                result.push(ch);
+                in_numeric_literal = true;
+            } else if in_numeric_literal && (ch.is_ascii_alphanumeric() || ch == '_') {
+                // Part of a base#value literal — don't expand as variable
+                result.push(ch);
+            } else if ch.is_ascii_digit() {
+                result.push(ch);
+                // Check for 0x/0X hex prefix
+                if ch == '0' {
+                    if let Some(&next) = chars.peek() {
+                        if next == 'x' || next == 'X' {
+                            result.push(chars.next().unwrap());
+                            in_numeric_literal = true;
+                        }
+                    }
+                }
             } else if ch.is_ascii_alphabetic() || ch == '_' {
+                in_numeric_literal = false;
                 // Could be a variable name
                 let mut name = String::new();
                 name.push(ch);
@@ -4457,6 +4531,7 @@ impl Interpreter {
                     result.push_str(&value);
                 }
             } else {
+                in_numeric_literal = false;
                 result.push(ch);
             }
         }
@@ -4688,17 +4763,28 @@ impl Interpreter {
             }
         }
 
-        // Multiplication/Division/Modulo (higher precedence)
+        // Multiplication/Division/Modulo (higher precedence, skip ** which is power)
         depth = 0;
         for i in (0..chars.len()).rev() {
             match chars[i] {
                 '(' => depth += 1,
                 ')' => depth -= 1,
-                '*' | '/' | '%' if depth == 0 => {
+                '*' if depth == 0 => {
+                    // Skip ** (power operator handled below)
+                    if i + 1 < chars.len() && chars[i + 1] == '*' {
+                        continue;
+                    }
+                    if i > 0 && chars[i - 1] == '*' {
+                        continue;
+                    }
+                    let left = self.parse_arithmetic_impl(&expr[..i], arith_depth + 1);
+                    let right = self.parse_arithmetic_impl(&expr[i + 1..], arith_depth + 1);
+                    return left * right;
+                }
+                '/' | '%' if depth == 0 => {
                     let left = self.parse_arithmetic_impl(&expr[..i], arith_depth + 1);
                     let right = self.parse_arithmetic_impl(&expr[i + 1..], arith_depth + 1);
                     return match chars[i] {
-                        '*' => left * right,
                         '/' => {
                             if right != 0 {
                                 left / right
@@ -4720,6 +4806,62 @@ impl Interpreter {
             }
         }
 
+        // Exponentiation ** (right-associative, higher precedence than */%)
+        depth = 0;
+        for i in 0..chars.len() {
+            match chars[i] {
+                '(' => depth += 1,
+                ')' => depth -= 1,
+                '*' if depth == 0 && i + 1 < chars.len() && chars[i + 1] == '*' => {
+                    let left = self.parse_arithmetic_impl(&expr[..i], arith_depth + 1);
+                    // Right-associative: parse from i+2 onward (may contain more **)
+                    let right = self.parse_arithmetic_impl(&expr[i + 2..], arith_depth + 1);
+                    return left.pow(right as u32);
+                }
+                _ => {}
+            }
+        }
+
+        // Unary negation and bitwise NOT
+        if let Some(rest) = expr.strip_prefix('-') {
+            let rest = rest.trim();
+            if !rest.is_empty() {
+                return -self.parse_arithmetic_impl(rest, arith_depth + 1);
+            }
+        }
+        if let Some(rest) = expr.strip_prefix('~') {
+            let rest = rest.trim();
+            if !rest.is_empty() {
+                return !self.parse_arithmetic_impl(rest, arith_depth + 1);
+            }
+        }
+        if let Some(rest) = expr.strip_prefix('!') {
+            let rest = rest.trim();
+            if !rest.is_empty() {
+                let val = self.parse_arithmetic_impl(rest, arith_depth + 1);
+                return if val == 0 { 1 } else { 0 };
+            }
+        }
+
+        // Base conversion: base#value (e.g., 16#ff = 255, 2#1010 = 10)
+        if let Some(hash_pos) = expr.find('#') {
+            let base_str = &expr[..hash_pos];
+            let value_str = &expr[hash_pos + 1..];
+            if let Ok(base) = base_str.parse::<u32>() {
+                if (2..=64).contains(&base) {
+                    return i64::from_str_radix(value_str, base).unwrap_or(0);
+                }
+            }
+        }
+
+        // Hex (0x...), octal (0...) literals
+        if expr.starts_with("0x") || expr.starts_with("0X") {
+            return i64::from_str_radix(&expr[2..], 16).unwrap_or(0);
+        }
+        if expr.starts_with('0') && expr.len() > 1 && expr.chars().all(|c| c.is_ascii_digit()) {
+            return i64::from_str_radix(&expr[1..], 8).unwrap_or(0);
+        }
+
         // Parse as number
         expr.trim().parse().unwrap_or(0)
     }

crates/bashkit/tests/spec_cases/bash/arithmetic.test.sh

@@ -201,3 +201,73 @@ echo $((1 || 0 && 0))
 ### expect
 1
 ### end
+
+### arith_exponentiation
+# ** power operator
+echo $((2 ** 10))
+### expect
+1024
+### end
+
+### arith_exponentiation_variable
+# ** with variable
+x=5; echo $(( x ** 2 ))
+### expect
+25
+### end
+
+### arith_base_hex
+# Base conversion: 16#ff = 255
+echo $((16#ff))
+### expect
+255
+### end
+
+### arith_base_binary
+# Base conversion: 2#1010 = 10
+echo $((2#1010))
+### expect
+10
+### end
+
+### arith_base_octal
+# Base conversion: 8#77 = 63
+echo $((8#77))
+### expect
+63
+### end
+
+### arith_hex_literal
+# 0x hex literal
+echo $((0xff))
+### expect
+255
+### end
+
+### arith_octal_literal
+# Octal literal
+echo $((077))
+### expect
+63
+### end
+
+### arith_unary_negate
+# Unary negation
+echo $((-5))
+### expect
+-5
+### end
+
+### arith_bitwise_not
+# Bitwise NOT
+echo $((~0))
+### expect
+-1
+### end
+
+### arith_logical_not
+# Logical NOT
+echo $((!0))
+### expect
+1
+### end

crates/bashkit/tests/spec_cases/bash/arrays.test.sh

@@ -154,3 +154,31 @@ b
 2
 3
 ### end
+
+### mapfile_basic
+### bash_diff: pipes don't create subshells in bashkit (stateless model)
+# mapfile reads lines into array from pipe
+printf 'a\nb\nc\n' | mapfile -t lines; echo ${#lines[@]}; echo ${lines[0]}; echo ${lines[1]}; echo ${lines[2]}
+### expect
+3
+a
+b
+c
+### end
+
+### readarray_alias
+### bash_diff: pipes don't create subshells in bashkit (stateless model)
+# readarray is an alias for mapfile
+printf 'x\ny\n' | readarray -t arr; echo ${arr[0]} ${arr[1]}
+### expect
+x y
+### end
+
+### mapfile_default_name
+### bash_diff: pipes don't create subshells in bashkit (stateless model)
+# mapfile default array name is MAPFILE
+printf 'hello\nworld\n' | mapfile -t; echo ${MAPFILE[0]}; echo ${MAPFILE[1]}
+### expect
+hello
+world
+### end