tova 0.9.5 → 0.9.6

package/bin/tova.js

@@ -5520,6 +5520,17 @@ function collectExports(ast, filename) {
       if (node.isPublic) publicExports.add(node.name);
     }
     if (node.type === 'ImplDeclaration') { /* impl doesn't export a name */ }
+    if (node.type === 'ReExportDeclaration') {
+      if (node.specifiers) {
+        // Named re-exports: pub { a, b as c } from "module"
+        for (const spec of node.specifiers) {
+          publicExports.add(spec.exported);
+          allNames.add(spec.exported);
+        }
+      }
+      // Wildcard re-exports: pub * from "module" — can't enumerate statically,
+      // but mark as having re-exports so import validation can allow through
+    }
   }
 
   for (const node of ast.body) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tova",
-  "version": "0.9.5",
+  "version": "0.9.6",
   "description": "Tova — a modern programming language that transpiles to JavaScript, unifying frontend and backend",
   "type": "module",
   "main": "src/index.js",

package/src/analyzer/analyzer.js

@@ -13,6 +13,7 @@ import { ErrorCode, WarningCode } from '../diagnostics/error-codes.js';
 
 // Pre-allocated constants for hot-path type checking (avoid per-call allocation)
 const ARITHMETIC_OPS = new Set(['-', '*', '/', '%', '**']);
+const BITWISE_OPS = new Set(['&', '|', '^', '<<', '>>', '>>>']);
 const NUMERIC_TYPES = new Set(['Int', 'Float']);
 
 const _JS_GLOBALS = new Set([
@@ -531,11 +532,13 @@ export class Analyzer {
           if (lt === 'String' || rt === 'String') return 'String';
           return 'Int';
         }
+        if (BITWISE_OPS.has(expr.operator)) return 'Int';
         if (['==', '!=', '<', '>', '<=', '>='].includes(expr.operator)) return 'Bool';
         return null;
       case 'UnaryExpression':
         if (expr.operator === 'not' || expr.operator === '!') return 'Bool';
         if (expr.operator === '-') return this._inferType(expr.operand);
+        if (expr.operator === '~') return 'Int';
         return null;
       case 'LogicalExpression':
         return 'Bool';
@@ -772,6 +775,7 @@ export class Analyzer {
       case 'ImportDeclaration': return this.visitImportDeclaration(node);
       case 'ImportDefault': return this.visitImportDefault(node);
       case 'ImportWildcard': return this.visitImportWildcard(node);
+      case 'ReExportDeclaration': return; // re-exports don't define local symbols
       case 'IfStatement': return this.visitIfStatement(node);
       case 'ForStatement': return this.visitForStatement(node);
       case 'WhileStatement': return this.visitWhileStatement(node);
@@ -881,6 +885,22 @@ export class Analyzer {
         // Argument count and type validation for known functions
         this._checkCallArgCount(node);
         this._checkCallArgTypes(node);
+        // W_UNSAFE_UNWRAP: detect .unwrap() and .expect() on Result/Option
+        if (node.callee.type === 'MemberExpression' && !node.callee.computed) {
+          const methodName = node.callee.property;
+          if (methodName === 'unwrap' || methodName === 'expect') {
+            const objType = this._inferType(node.callee.object);
+            if (objType && (objType.startsWith('Result') || objType.startsWith('Option') ||
+                objType === 'Result' || objType === 'Option')) {
+              this.warn(
+                `Unsafe ${methodName}() call on ${objType} — will panic if value is ${objType.startsWith('Result') ? 'Err' : 'None'}`,
+                node.loc,
+                'consider using unwrapOr(default) or match for safe error handling',
+                { code: 'W_UNSAFE_UNWRAP' }
+              );
+            }
+          }
+        }
         // W_UNSAFE_INTERPOLATION: detect template literals in database calls
         if (node.callee.type === 'MemberExpression' && !node.callee.computed) {
           const prop = node.callee.property;
@@ -910,6 +930,49 @@ export class Analyzer {
       case 'OptionalChain':
         this.visitExpression(node.object);
         if (node.computed) this.visitExpression(node.property);
+        // Type-aware checks (only for non-computed property access)
+        if (!node.computed && typeof node.property === 'string') {
+          const objType = this._inferType(node.object);
+          if (objType) {
+            // W_NULL_ACCESS: property access on nil
+            if (objType === 'Nil' && node.type !== 'OptionalChain') {
+              this.warn(
+                `Accessing property '${node.property}' on nil value`,
+                node.loc,
+                'this will always fail at runtime',
+                { code: 'W_NULL_ACCESS' }
+              );
+            }
+            // W_NULL_ACCESS: property access on Option without optional chaining
+            else if ((objType === 'Option' || objType.startsWith('Option<')) && node.type !== 'OptionalChain') {
+              this.warn(
+                `Option value may be None — use '?.' or unwrap before accessing '${node.property}'`,
+                node.loc,
+                'consider using ?. for safe access or unwrapOr(default)',
+                { code: 'W_NULL_ACCESS' }
+              );
+            }
+            // W_UNKNOWN_FIELD: access unknown field on user-defined type
+            else {
+              const BUILTIN_TYPES = new Set(['String', 'Int', 'Float', 'Bool', 'Array', 'Result', 'Option', 'Map', 'Set', 'Nil', 'Any']);
+              const baseType = objType.includes('<') ? objType.slice(0, objType.indexOf('<')) : objType;
+              if (!BUILTIN_TYPES.has(baseType) && !objType.startsWith('[') && !objType.startsWith('(')) {
+                const typeStructure = this.typeRegistry.types.get(objType);
+                if (typeStructure instanceof ADTType) {
+                  const fieldType = typeStructure.getFieldType(node.property);
+                  if (!fieldType) {
+                    this.warn(
+                      `Type '${objType}' has no field '${node.property}'`,
+                      node.loc,
+                      `available fields: ${[...new Set([...typeStructure.variants.values()].flatMap(v => [...v.keys()]))].join(', ') || 'none'}`,
+                      { code: 'W_UNKNOWN_FIELD' }
+                    );
+                  }
+                }
+              }
+            }
+          }
+        }
         return;
       case 'PipeExpression':
         this.visitExpression(node.left);
@@ -921,6 +984,23 @@ export class Analyzer {
         return this.visitMatchExpression(node);
       case 'ArrayLiteral':
         for (const el of node.elements) this.visitExpression(el);
+        if (node.elements.length > 1) {
+          const firstType = this._inferType(node.elements[0]);
+          if (firstType && firstType !== 'Any') {
+            for (let i = 1; i < node.elements.length; i++) {
+              const elType = this._inferType(node.elements[i]);
+              if (elType && elType !== 'Any' && !this._typesCompatible(firstType, elType)) {
+                this.warn(
+                  `Array contains mixed types: expected [${firstType}] but found ${elType} at index ${i}`,
+                  node.elements[i].loc || node.loc,
+                  `ensure all elements are ${firstType}`,
+                  { code: 'W209' }
+                );
+                break;
+              }
+            }
+          }
+        }
         return;
       case 'ObjectLiteral':
         for (const prop of node.properties) {
@@ -2111,8 +2191,8 @@ export class Analyzer {
           if (!this._typesCompatible(existing.inferredType, newType)) {
             this.strictError(`Type mismatch: '${target}' is ${existing.inferredType}, but assigned ${newType}`, node.loc, this._conversionHint(existing.inferredType, newType), { code: 'E102' });
           }
-          // Float narrowing warning in strict mode
-          if (this.strict && newType === 'Float' && existing.inferredType === 'Int') {
+          // Float narrowing warning
+          if (newType === 'Float' && existing.inferredType === 'Int') {
             this.warn(`Potential data loss: assigning Float to Int variable '${target}'`, node.loc, "use floor() or round() for explicit conversion", { code: 'W204' });
           }
         }
@@ -3566,6 +3646,14 @@ export class Analyzer {
         const hint = rightType === 'String' ? "try toInt(value) or toFloat(value) to parse" : null;
         this.strictError(`Type mismatch: '+' expects numeric type, but got ${rightType}`, node.loc, hint);
       }
+    } else if (BITWISE_OPS.has(op)) {
+      // Bitwise: both sides must be Int
+      if (leftType && leftType !== 'Int' && leftType !== 'Any') {
+        this.strictError(`Type mismatch: '${op}' expects Int, but got ${leftType}`, node.loc);
+      }
+      if (rightType && rightType !== 'Int' && rightType !== 'Any') {
+        this.strictError(`Type mismatch: '${op}' expects Int, but got ${rightType}`, node.loc);
+      }
     }
   }
 

package/src/codegen/base-codegen.js

@@ -279,6 +279,7 @@ export class BaseCodegen {
       case 'ImportDeclaration': result = this.genImport(node); break;
       case 'ImportDefault': result = this.genImportDefault(node); break;
       case 'ImportWildcard': result = this.genImportWildcard(node); break;
+      case 'ReExportDeclaration': result = this.genReExport(node); break;
       case 'IfStatement': result = this.genIfStatement(node); break;
       case 'ForStatement': result = this.genForStatement(node); break;
       case 'WhileStatement': result = this.genWhileStatement(node); break;
@@ -665,6 +666,19 @@ export class BaseCodegen {
     return `${this.i()}import * as ${node.local} from ${JSON.stringify(node.source)};`;
   }
 
+  genReExport(node) {
+    this._rewriteImportSource(node);
+    if (!node.specifiers) {
+      // pub * from "module" → export * from "module"
+      return `${this.i()}export * from ${JSON.stringify(node.source)};`;
+    }
+    // pub { a, b as c } from "module" → export { a, b as c } from "module"
+    const specs = node.specifiers.map(s =>
+      s.imported === s.exported ? s.imported : `${s.imported} as ${s.exported}`
+    ).join(', ');
+    return `${this.i()}export { ${specs} } from ${JSON.stringify(node.source)};`;
+  }
+
   genIfStatement(node) {
     const p = [];
     p.push(`${this.i()}if (${this.genExpression(node.condition)}) {\n`);
@@ -1301,7 +1315,7 @@ export class BaseCodegen {
   genBinaryExpression(node) {
     const op = node.operator;
 
-    // Constant folding: arithmetic on two number literals
+    // Constant folding: arithmetic and bitwise on two number literals
     if (node.left.type === 'NumberLiteral' && node.right.type === 'NumberLiteral') {
       const l = node.left.value, r = node.right.value;
       let folded = null;
@@ -1312,6 +1326,12 @@ export class BaseCodegen {
         case '/': if (r !== 0) folded = l / r; break;
         case '%': if (r !== 0) folded = l % r; break;
         case '**': folded = l ** r; break;
+        case '&': folded = l & r; break;
+        case '|': folded = l | r; break;
+        case '^': folded = l ^ r; break;
+        case '<<': folded = l << r; break;
+        case '>>': folded = l >> r; break;
+        case '>>>': folded = l >>> r; break;
       }
       if (folded !== null && Number.isFinite(folded)) {
         return folded < 0 ? `(${folded})` : String(folded);
@@ -1348,6 +1368,10 @@ export class BaseCodegen {
   }
 
   genUnaryExpression(node) {
+    // Constant folding: bitwise NOT on number literal
+    if (node.operator === '~' && node.operand.type === 'NumberLiteral') {
+      return String(~node.operand.value);
+    }
     const operand = this.genExpression(node.operand);
     if (node.operator === 'not') return `(!${operand})`;
     return `(${node.operator}${operand})`;

package/src/lexer/lexer.js

@@ -1089,6 +1089,20 @@ export class Lexer {
         break;
 
       case '<':
+        if (this.peek() === '<') {
+          // Left shift: << or <<=
+          // Only treat as shift if previous token produces a value (avoids `< <JSXTag>`)
+          const prevTok = this.tokens.length > 0 ? this.tokens[this.tokens.length - 1] : null;
+          if (prevTok && Lexer.VALUE_TOKEN_TYPES.has(prevTok.type)) {
+            this.advance(); // consume second <
+            if (this.match('=')) {
+              this.tokens.push(new Token(TokenType.LEFT_SHIFT_ASSIGN, '<<=', startLine, startCol));
+            } else {
+              this.tokens.push(new Token(TokenType.LEFT_SHIFT, '<<', startLine, startCol));
+            }
+            break;
+          }
+        }
         if (this.match('=')) {
           this.tokens.push(new Token(TokenType.LESS_EQUAL, '<=', startLine, startCol));
         } else {
@@ -1140,12 +1154,13 @@ export class Lexer {
       case '&':
         if (this.match('&')) {
           this.tokens.push(new Token(TokenType.AND_AND, '&&', startLine, startCol));
+        } else if (this.match('=')) {
+          this.tokens.push(new Token(TokenType.BIT_AND_ASSIGN, '&=', startLine, startCol));
         } else if (this._jsxStack.length > 0) {
-          // Inside JSX, & is valid text - should not reach here normally
-          // but handle gracefully by treating as text
+          // Inside JSX, & is valid text
           this.tokens.push(new Token(TokenType.JSX_TEXT, '&', startLine, startCol));
         } else {
-          this.error(`Unexpected character: '&'. Did you mean '&&'?`);
+          this.tokens.push(new Token(TokenType.AMPERSAND, '&', startLine, startCol));
         }
         break;
 
@@ -1154,6 +1169,8 @@ export class Lexer {
           this.tokens.push(new Token(TokenType.PIPE, '|>', startLine, startCol));
         } else if (this.match('|')) {
           this.tokens.push(new Token(TokenType.OR_OR, '||', startLine, startCol));
+        } else if (this.match('=')) {
+          this.tokens.push(new Token(TokenType.BIT_OR_ASSIGN, '|=', startLine, startCol));
         } else {
           this.tokens.push(new Token(TokenType.BAR, '|', startLine, startCol));
         }
@@ -1195,6 +1212,18 @@ export class Lexer {
         this.tokens.push(new Token(TokenType.AT, '@', startLine, startCol));
         break;
 
+      case '^':
+        if (this.match('=')) {
+          this.tokens.push(new Token(TokenType.BIT_XOR_ASSIGN, '^=', startLine, startCol));
+        } else {
+          this.tokens.push(new Token(TokenType.CARET, '^', startLine, startCol));
+        }
+        break;
+
+      case '~':
+        this.tokens.push(new Token(TokenType.TILDE, '~', startLine, startCol));
+        break;
+
       default:
         this.error(`Unexpected character: '${ch}'`);
     }

package/src/lexer/tokens.js

@@ -141,6 +141,17 @@ export const TokenType = {
   MINUS_ASSIGN: 'MINUS_ASSIGN', // -=
   STAR_ASSIGN: 'STAR_ASSIGN', // *=
   SLASH_ASSIGN: 'SLASH_ASSIGN', // /=
+  AMPERSAND: 'AMPERSAND',       // &
+  CARET: 'CARET',               // ^
+  TILDE: 'TILDE',               // ~
+  LEFT_SHIFT: 'LEFT_SHIFT',     // <<
+  RIGHT_SHIFT: 'RIGHT_SHIFT',   // >>
+  UNSIGNED_RIGHT_SHIFT: 'UNSIGNED_RIGHT_SHIFT', // >>>
+  BIT_AND_ASSIGN: 'BIT_AND_ASSIGN', // &=
+  BIT_OR_ASSIGN: 'BIT_OR_ASSIGN',   // |=
+  BIT_XOR_ASSIGN: 'BIT_XOR_ASSIGN', // ^=
+  LEFT_SHIFT_ASSIGN: 'LEFT_SHIFT_ASSIGN',   // <<=
+  RIGHT_SHIFT_ASSIGN: 'RIGHT_SHIFT_ASSIGN', // >>=
 
   // Delimiters
   LPAREN: 'LPAREN',           // (

package/src/lsp/server.js

@@ -516,7 +516,7 @@ class TovaLanguageServer {
 
     // Keywords
     const keywords = [
-      'fn', 'let', 'if', 'elif', 'else', 'for', 'while', 'loop', 'when', 'in',
+      'fn', 'if', 'elif', 'else', 'for', 'while', 'loop', 'when', 'in',
       'return', 'match', 'type', 'import', 'from', 'true', 'false',
       'nil', 'server', 'browser', 'client', 'shared', 'pub', 'mut',
       'try', 'catch', 'finally', 'break', 'continue', 'async', 'await',

package/src/parser/ast.js

@@ -215,6 +215,26 @@ export class ImportWildcard {
   }
 }
 
+// Re-export: pub { a, b as c } from "module"
+export class ReExportDeclaration {
+  constructor(specifiers, source, loc) {
+    this.type = 'ReExportDeclaration';
+    this.specifiers = specifiers; // [{imported, exported}] or null for wildcard
+    this.source = source;         // module path string
+    this.loc = loc;
+  }
+}
+
+// Re-export specifier: individual name in pub { a, b as c } from "module"
+export class ReExportSpecifier {
+  constructor(imported, exported, loc) {
+    this.type = 'ReExportSpecifier';
+    this.imported = imported;  // original name
+    this.exported = exported;  // re-exported name (same as imported if no alias)
+    this.loc = loc;
+  }
+}
+
 // ============================================================
 // Statements
 // ============================================================

package/src/parser/parser.js

@@ -559,7 +559,7 @@ export class Parser {
     if (this.check(TokenType.TYPE)) return this.parseTypeDeclaration();
     if (this.check(TokenType.MUT)) this.error("'mut' is not supported in Tova. Use 'var' for mutable variables");
     if (this.check(TokenType.VAR)) return this.parseVarDeclaration();
-    if (this.check(TokenType.LET)) return this.parseLetDestructure();
+    if (this.check(TokenType.LET)) this.error("'let' is not needed in Tova. Destructure directly: {a, b} = obj, [a, b] = list, or (a, b) = pair");
     if (this.check(TokenType.IF)) return this.parseIfStatement();
     if (this.check(TokenType.FOR)) return this.parseForStatement();
     if (this.check(TokenType.WHILE)) return this.parseWhileStatement();
@@ -599,6 +599,13 @@ export class Parser {
     if (this.check(TokenType.PUB)) {
       this.error("Duplicate 'pub' modifier");
     }
+    // Re-export: pub { a, b } from "module" or pub * from "module"
+    if (this.check(TokenType.STAR) && this.peek(1).type === TokenType.FROM) {
+      return this.parseReExport(l);
+    }
+    if (this.check(TokenType.LBRACE) && this._looksLikeReExport()) {
+      return this.parseReExport(l);
+    }
     // Handle pub component at top level (parseComponent is installed by browser-parser plugin)
     if (this.check(TokenType.COMPONENT) && typeof this.parseComponent === 'function') {
       const comp = this.parseComponent();
@@ -610,6 +617,61 @@ export class Parser {
     return stmt;
   }
 
+  // Check if pub { ... } is a re-export (identifiers with optional aliases, then } from "...")
+  _looksLikeReExport() {
+    let i = 1; // start after {
+    while (true) {
+      const tok = this.peek(i);
+      if (!tok || tok.type === TokenType.EOF) return false;
+      if (tok.type === TokenType.RBRACE) {
+        // After }, must see FROM
+        const after = this.peek(i + 1);
+        return after && after.type === TokenType.FROM;
+      }
+      // Inside: expect IDENTIFIER, optionally AS IDENTIFIER, then COMMA or RBRACE
+      if (tok.type !== TokenType.IDENTIFIER) return false;
+      i++;
+      const next = this.peek(i);
+      if (next && next.type === TokenType.AS) {
+        i++; // skip as
+        i++; // skip alias identifier
+      }
+      const afterId = this.peek(i);
+      if (!afterId) return false;
+      if (afterId.type === TokenType.COMMA) { i++; continue; }
+      if (afterId.type === TokenType.RBRACE) continue;
+      return false;
+    }
+  }
+
+  parseReExport(l) {
+    if (this.match(TokenType.STAR)) {
+      // pub * from "module"
+      this.expect(TokenType.FROM, "Expected 'from' after 'pub *'");
+      const source = this.expect(TokenType.STRING, "Expected module path string").value;
+      return new AST.ReExportDeclaration(null, source, l);
+    }
+    // pub { a, b as c } from "module"
+    this.expect(TokenType.LBRACE);
+    const specifiers = [];
+    while (!this.check(TokenType.RBRACE)) {
+      const specL = this.loc();
+      const imported = this.expect(TokenType.IDENTIFIER, "Expected export name").value;
+      let exported = imported;
+      if (this.match(TokenType.AS)) {
+        exported = this.expect(TokenType.IDENTIFIER, "Expected alias name after 'as'").value;
+      }
+      specifiers.push(new AST.ReExportSpecifier(imported, exported, specL));
+      if (!this.check(TokenType.RBRACE)) {
+        this.expect(TokenType.COMMA, "Expected ',' or '}' in re-export list");
+      }
+    }
+    this.expect(TokenType.RBRACE);
+    this.expect(TokenType.FROM, "Expected 'from' after re-export specifiers");
+    const source = this.expect(TokenType.STRING, "Expected module path string").value;
+    return new AST.ReExportDeclaration(specifiers, source, l);
+  }
+
   parseImplDeclaration() {
     const l = this.loc();
     this.expect(TokenType.IMPL);
@@ -1495,23 +1557,56 @@ export class Parser {
       }
       // Destructuring without let: {name, age} = user  or  [a, b] = list
       if (expr.type === 'ObjectLiteral') {
-        const pattern = new AST.ObjectPattern(
-          expr.properties.map(p => {
-            const key = typeof p.key === 'string' ? p.key : p.key.name || p.key;
-            // For shorthand {name}, key and value are the same
-            // For rename {name: alias}, value is the alias identifier
-            const val = p.shorthand ? key
-              : (p.value && p.value.type === 'Identifier' ? p.value.name : key);
-            return { key, value: val };
-          }),
-          expr.loc
-        );
+        let pattern;
+        if (expr._isDestructurePattern) {
+          // Already parsed as a destructuring pattern with defaults
+          pattern = new AST.ObjectPattern(
+            expr.properties.map(p => {
+              const key = typeof p.key === 'string' ? p.key : p.key.name || p.key;
+              const val = p.shorthand ? key
+                : (p.value && p.value.type === 'Identifier' ? p.value.name : key);
+              return { key, value: val, defaultValue: p.defaultValue || null };
+            }),
+            expr.loc
+          );
+        } else {
+          pattern = new AST.ObjectPattern(
+            expr.properties.map(p => {
+              const key = typeof p.key === 'string' ? p.key : p.key.name || p.key;
+              let val, defaultValue = p.defaultValue || null;
+              if (p.shorthand) {
+                // Shorthand with default: { x = 10 } — either via _parseObjectProperty defaultValue or Assignment
+                if (!defaultValue && p.value && p.value.type === 'Assignment' && p.value.targets) {
+                  val = key;
+                  defaultValue = p.value.values[0];
+                } else {
+                  val = key;
+                }
+              } else {
+                // Non-shorthand: { x: y } or { x: y = 10 }
+                if (!defaultValue && p.value && p.value.type === 'Assignment' && p.value.targets) {
+                  // { x: y = 10 } — value parsed as Assignment(y, 10)
+                  val = p.value.targets[0];
+                  if (typeof val !== 'string' && val.name) val = val.name;
+                  defaultValue = p.value.values[0];
+                } else if (p.value && p.value.type === 'Identifier') {
+                  val = p.value.name;
+                } else {
+                  val = key;
+                }
+              }
+              return { key, value: val, defaultValue };
+            }),
+            expr.loc
+          );
+        }
         const value = this.parseExpression();
         return new AST.LetDestructure(pattern, value, l);
       }
       if (expr.type === 'ArrayLiteral') {
         const pattern = new AST.ArrayPattern(
           expr.elements.map(e => {
+            if (e.type === 'Identifier' && e.name === '_') return null;
             if (e.type === 'Identifier') return e.name;
             if (e.type === 'SpreadExpression' && e.argument && e.argument.type === 'Identifier') {
               return '...' + e.argument.name;
@@ -1523,11 +1618,24 @@ export class Parser {
         const value = this.parseExpression();
         return new AST.LetDestructure(pattern, value, l);
       }
+      // Tuple destructuring without let: (a, b) = expr
+      if (expr.type === 'TupleExpression') {
+        const pattern = new AST.TuplePattern(
+          expr.elements.map(e => {
+            if (e.type === 'Identifier') return e.name;
+            return '_';
+          }),
+          expr.loc
+        );
+        const value = this.parseExpression();
+        return new AST.LetDestructure(pattern, value, l);
+      }
       this.error("Invalid assignment target");
     }
 
-    // Compound assignment: x += expr
-    const compoundOp = this.match(TokenType.PLUS_ASSIGN, TokenType.MINUS_ASSIGN, TokenType.STAR_ASSIGN, TokenType.SLASH_ASSIGN);
+    // Compound assignment: x += expr, x &= expr, etc.
+    const compoundOp = this.match(TokenType.PLUS_ASSIGN, TokenType.MINUS_ASSIGN, TokenType.STAR_ASSIGN, TokenType.SLASH_ASSIGN,
+      TokenType.BIT_AND_ASSIGN, TokenType.BIT_OR_ASSIGN, TokenType.BIT_XOR_ASSIGN, TokenType.LEFT_SHIFT_ASSIGN, TokenType.RIGHT_SHIFT_ASSIGN);
     if (compoundOp) {
       if (expr.type !== 'Identifier' && expr.type !== 'MemberExpression') {
         this.error("Invalid compound assignment target");
@@ -1652,7 +1760,46 @@ export class Parser {
       const operand = this.parseNot();
       return new AST.UnaryExpression('not', operand, true, l);
     }
-    return this.parseComparison();
+    if (this.match(TokenType.TILDE)) {
+      const opTok = this.tokens[this.pos - 1];
+      const l = { line: opTok.line, column: opTok.column, file: this.filename };
+      const operand = this.parseNot();
+      return new AST.UnaryExpression('~', operand, true, l);
+    }
+    return this.parseBitwiseOr();
+  }
+
+  parseBitwiseOr() {
+    let left = this.parseBitwiseXor();
+    while (this.match(TokenType.BAR)) {
+      const opTok = this.tokens[this.pos - 1];
+      const l = { line: opTok.line, column: opTok.column, file: this.filename };
+      const right = this.parseBitwiseXor();
+      left = new AST.BinaryExpression('|', left, right, l);
+    }
+    return left;
+  }
+
+  parseBitwiseXor() {
+    let left = this.parseBitwiseAnd();
+    while (this.match(TokenType.CARET)) {
+      const opTok = this.tokens[this.pos - 1];
+      const l = { line: opTok.line, column: opTok.column, file: this.filename };
+      const right = this.parseBitwiseAnd();
+      left = new AST.BinaryExpression('^', left, right, l);
+    }
+    return left;
+  }
+
+  parseBitwiseAnd() {
+    let left = this.parseComparison();
+    while (this.match(TokenType.AMPERSAND)) {
+      const opTok = this.tokens[this.pos - 1];
+      const l = { line: opTok.line, column: opTok.column, file: this.filename };
+      const right = this.parseComparison();
+      left = new AST.BinaryExpression('&', left, right, l);
+    }
+    return left;
   }
 
   parseComparison() {
@@ -1719,24 +1866,51 @@ export class Parser {
   }
 
   parseRange() {
-    let left = this.parseAddition();
+    let left = this.parseShift();
 
     if (this.check(TokenType.DOT_DOT_EQUAL)) {
       const l = this.loc();
       this.advance();
-      const right = this.parseAddition();
+      const right = this.parseShift();
       return new AST.RangeExpression(left, right, true, l);
     }
     if (this.check(TokenType.DOT_DOT)) {
       const l = this.loc();
       this.advance();
-      const right = this.parseAddition();
+      const right = this.parseShift();
       return new AST.RangeExpression(left, right, false, l);
     }
 
     return left;
   }
 
+  parseShift() {
+    let left = this.parseAddition();
+    while (true) {
+      const l = this.loc();
+      if (this.match(TokenType.LEFT_SHIFT)) {
+        const right = this.parseAddition();
+        left = new AST.BinaryExpression('<<', left, right, l);
+      } else if (this.check(TokenType.GREATER) && this.peek(1).type === TokenType.GREATER) {
+        // >> or >>> — consume consecutive > tokens in expression context
+        const firstGt = this.advance(); // consume first >
+        if (this.check(TokenType.GREATER) && this.peek(1).type === TokenType.GREATER) {
+          this.advance(); // consume second >
+          this.advance(); // consume third > (completing >>>)
+          const right = this.parseAddition();
+          left = new AST.BinaryExpression('>>>', left, right, { line: firstGt.line, column: firstGt.column, file: this.filename });
+        } else {
+          this.advance(); // consume second > (completing >>)
+          const right = this.parseAddition();
+          left = new AST.BinaryExpression('>>', left, right, { line: firstGt.line, column: firstGt.column, file: this.filename });
+        }
+      } else {
+        break;
+      }
+    }
+    return left;
+  }
+
   parseAddition() {
     let left = this.parseMultiplication();
     while (true) {
@@ -2104,7 +2278,8 @@ export class Parser {
     } else {
       // Parse expression, then check for compound/simple assignment
       const expr = this.parseExpression();
-      const compoundOp = this.match(TokenType.PLUS_ASSIGN, TokenType.MINUS_ASSIGN, TokenType.STAR_ASSIGN, TokenType.SLASH_ASSIGN);
+      const compoundOp = this.match(TokenType.PLUS_ASSIGN, TokenType.MINUS_ASSIGN, TokenType.STAR_ASSIGN, TokenType.SLASH_ASSIGN,
+        TokenType.BIT_AND_ASSIGN, TokenType.BIT_OR_ASSIGN, TokenType.BIT_XOR_ASSIGN, TokenType.LEFT_SHIFT_ASSIGN, TokenType.RIGHT_SHIFT_ASSIGN);
       if (compoundOp) {
         const value = this.parseExpression();
         body = new AST.CompoundAssignment(expr, compoundOp.value, value, l);
@@ -2347,6 +2522,23 @@ export class Parser {
       const argument = this.parseUnary();
       return { spread: true, argument };
     }
+    // Destructuring shorthand with default: x = 10
+    if (this.check(TokenType.IDENTIFIER) && this.peek(1).type === TokenType.ASSIGN) {
+      const key = { type: 'Identifier', name: this.advance().value };
+      this.advance(); // consume =
+      const defaultValue = this.parseExpression();
+      return { key, value: key, shorthand: true, defaultValue };
+    }
+    // Destructuring alias with default: key: alias = expr
+    if (this.check(TokenType.IDENTIFIER) && this.peek(1).type === TokenType.COLON
+        && this.peek(2).type === TokenType.IDENTIFIER && this.peek(3).type === TokenType.ASSIGN) {
+      const key = { type: 'Identifier', name: this.advance().value };
+      this.advance(); // consume :
+      const alias = { type: 'Identifier', name: this.advance().value };
+      this.advance(); // consume =
+      const defaultValue = this.parseExpression();
+      return { key, value: alias, shorthand: false, defaultValue };
+    }
     const key = this.parseExpression();
     if (this.match(TokenType.COLON)) {
       const value = this.parseExpression();
@@ -2378,6 +2570,17 @@ export class Parser {
       return new AST.ObjectLiteral(properties, l);
     }
 
+    // Detect destructuring pattern: { x = val } or { x: y = val }
+    // When IDENTIFIER is followed by ASSIGN, this is a destructuring default, not an object literal
+    if (this.check(TokenType.IDENTIFIER) && this.peek(1).type === TokenType.ASSIGN) {
+      return this._parseObjectPatternAsLiteral(l);
+    }
+    // { x: y = val } — identifier, colon, identifier, assign — destructuring with alias+default
+    if (this.check(TokenType.IDENTIFIER) && this.peek(1).type === TokenType.COLON
+        && this.peek(2).type === TokenType.IDENTIFIER && this.peek(3).type === TokenType.ASSIGN) {
+      return this._parseObjectPatternAsLiteral(l);
+    }
+
     // Try to parse first key: value pair
     const firstKey = this.parseExpression();
 
@@ -2427,6 +2630,42 @@ export class Parser {
     this.error("Invalid object literal");
   }
 
+  // Parse object destructuring pattern as an ObjectLiteral-like node for later conversion
+  // Handles: { a = 1, b: y = 2, c } patterns with defaults
+  // Note: the opening { has already been consumed by parseObjectOrDictComprehension
+  _parseObjectPatternAsLiteral(l) {
+    const properties = [];
+
+    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+      const key = this.expect(TokenType.IDENTIFIER, "Expected property name").value;
+      let valueName = key;
+      let defaultValue = null;
+
+      if (this.match(TokenType.COLON)) {
+        valueName = this.expect(TokenType.IDENTIFIER, "Expected alias name").value;
+      }
+      if (this.match(TokenType.ASSIGN)) {
+        defaultValue = this.parseExpression();
+      }
+
+      properties.push({
+        key: { type: 'Identifier', name: key },
+        value: { type: 'Identifier', name: valueName },
+        shorthand: key === valueName,
+        defaultValue: defaultValue
+      });
+      if (!this.match(TokenType.COMMA)) break;
+    }
+
+    this.expect(TokenType.RBRACE, "Expected '}' in object pattern");
+    return {
+      type: 'ObjectLiteral',
+      properties,
+      loc: l,
+      _isDestructurePattern: true
+    };
+  }
+
   parseParenOrArrowLambda() {
     const l = this.loc();
 

package/src/version.js

@@ -1,2 +1,2 @@
 // Auto-generated by scripts/embed-runtime.js — do not edit
-export const VERSION = "0.9.5";
+export const VERSION = "0.9.6";