arc-lang 0.6.2 → 0.6.4

package/dist/interpreter.js

@@ -126,7 +126,7 @@ function syncFetch(method, url, body) {
     const bodyJson = bodyStr != null ? JSON.stringify(bodyStr) : "null";
     // Pass config via env to avoid shell escaping issues
     const fetchConfig = JSON.stringify({ method, url, body: bodyStr, headers: customHeaders });
-    const script = `const c=JSON.parse(process.env.ARC_FETCH);(async()=>{const o={method:c.method,headers:{...c.headers}};if(c.body!==null){o.body=c.body;if(!o.headers["Content-Type"])o.headers["Content-Type"]="application/json";}try{const r=await fetch(c.url,o);const t=await r.text();let d;try{d=JSON.parse(t)}catch{d=t}console.log(JSON.stringify({ok:true,status:r.status,data:d}))}catch(e){console.log(JSON.stringify({ok:false,status:0,data:e.message}))}})()`;
+    const script = `const c=JSON.parse(process.env.ARC_FETCH);(async()=>{const o={method:c.method,headers:{...c.headers}};if(c.body!==null){o.body=c.body;if(!o.headers["Content-Type"])o.headers["Content-Type"]="application/json";}try{const r=await fetch(c.url,o);const t=await r.text();let d;try{d=JSON.parse(t)}catch{d=t}console.log(JSON.stringify({ok:r.status>=200&&r.status<300,status:r.status,data:d}))}catch(e){console.log(JSON.stringify({ok:false,status:0,data:e.message}))}})()`;
     try {
         const raw = execSync(`node -e "${script.replace(/"/g, '\\"')}"`, {
             timeout: 30000,
@@ -182,7 +182,7 @@ function makePrelude(env) {
         print: (...args) => { console.log(args.map(toStr).join(" ")); return null; },
         len: (v) => {
             if (typeof v === "string")
-                return v.length;
+                return [...v].length; // codepoint count, not UTF-16
             if (Array.isArray(v))
                 return v.length;
             if (v && typeof v === "object" && "__map" in v)
@@ -276,8 +276,28 @@ function makePrelude(env) {
         },
         starts: (s, pre) => typeof s === "string" ? s.startsWith(pre) : false,
         ends: (s, suf) => typeof s === "string" ? s.endsWith(suf) : false,
-        int: (v) => typeof v === "string" ? parseInt(v) : typeof v === "number" ? Math.floor(v) : 0,
-        float: (v) => typeof v === "string" ? parseFloat(v) : typeof v === "number" ? v : 0,
+        int: (v) => {
+            if (typeof v === "number")
+                return Math.floor(v);
+            if (typeof v === "string") {
+                const n = parseInt(v);
+                if (isNaN(n))
+                    throw new ArcRuntimeError(`ValueError: cannot convert '${v}' to int`, { code: ErrorCode.TYPE_MISMATCH });
+                return n;
+            }
+            return 0;
+        },
+        float: (v) => {
+            if (typeof v === "number")
+                return v;
+            if (typeof v === "string") {
+                const n = parseFloat(v);
+                if (isNaN(n))
+                    throw new ArcRuntimeError(`ValueError: cannot convert '${v}' to float`, { code: ErrorCode.TYPE_MISMATCH });
+                return n;
+            }
+            return 0;
+        },
         str: (v) => toStr(v),
         bool: (v) => isTruthy(v),
         min: (...args) => {
@@ -2361,6 +2381,11 @@ class ReturnSignal {
         this.value = value;
     }
 }
+// Break/Continue signals for loops
+class BreakSignal {
+}
+class ContinueSignal {
+}
 // Evaluate expression in tail position — returns TCOSignal for self-recursive tail calls
 function evalExprTCO(expr, env, fnName) {
     // Only handle tail-position expressions specially
@@ -2469,20 +2494,14 @@ function evalExpr(expr, env) {
                     if (typeof left !== "number" || typeof right !== "number")
                         throw new ArcRuntimeError(`TypeError: cannot divide non-numbers`, { code: ErrorCode.INVALID_OPERATOR, loc: expr.loc });
                     if (right === 0)
-                        throw new ArcRuntimeError(`Division by zero`, {
-                            code: ErrorCode.DIVISION_BY_ZERO, loc: expr.loc,
-                            suggestion: "Check that the divisor is not zero before dividing.",
-                        });
+                        return left === 0 ? null : (left > 0 ? Infinity : -Infinity);
                     return left / right;
                 }
                 case "%": {
                     if (typeof left !== "number" || typeof right !== "number")
                         throw new ArcRuntimeError(`TypeError: cannot modulo non-numbers`, { code: ErrorCode.INVALID_OPERATOR, loc: expr.loc });
                     if (right === 0)
-                        throw new ArcRuntimeError(`Modulo by zero`, {
-                            code: ErrorCode.DIVISION_BY_ZERO, loc: expr.loc,
-                            suggestion: "Check that the divisor is not zero before dividing.",
-                        });
+                        return null;
                     return left % right;
                 }
                 case "**": {
@@ -2576,8 +2595,24 @@ function evalExpr(expr, env) {
             if (obj && typeof obj === "object" && "__map" in obj) {
                 return obj.entries.get(expr.property) ?? null;
             }
-            throw new ArcRuntimeError(`Cannot access property '${expr.property}' on ${toStr(obj)}`, {
-                code: ErrorCode.PROPERTY_ACCESS, loc: expr.loc,
+            // Teaching error messages for common method-style access
+            const prop = expr.property;
+            const methodBuiltins = {
+                length: "len(value)", repeat: "repeat(str, n)", trim: "trim(str)",
+                split: "split(str, sep)", join: "join(list, sep)", replace: "replace(str, old, new)",
+                includes: "contains(value, sub)", startsWith: "starts(str, prefix)", endsWith: "ends(str, suffix)",
+                toUpperCase: "upper(str)", toLowerCase: "lower(str)", indexOf: "index_of(str, sub)",
+                slice: "slice(value, start, end)", map: "map(list, fn)", filter: "filter(list, fn)",
+                reduce: "reduce(list, fn, init)", find: "find(list, fn)", sort: "sort(list)",
+                reverse: "reverse(list)", push: "push(list, item)", concat: "concat(a, b)",
+                forEach: "for item in list { ... }", charAt: "char_at(str, i)",
+                toString: "str(value)", match: "use regex; regex.find(str, pattern)",
+            };
+            const suggestion = methodBuiltins[prop]
+                ? `Arc uses free functions, not methods. Try: ${methodBuiltins[prop]}`
+                : undefined;
+            throw new ArcRuntimeError(`Cannot access property '${prop}' on ${toStr(obj)}`, {
+                code: ErrorCode.PROPERTY_ACCESS, loc: expr.loc, suggestion,
             });
         }
         case "OptionalMemberExpr": {
@@ -2606,6 +2641,23 @@ function evalExpr(expr, env) {
             // Not a Result type — just return the value
             return val;
         }
+        case "TryCatchExpr": {
+            try {
+                return evalExpr(expr.body, env);
+            }
+            catch (e) {
+                if (e instanceof ReturnSignal)
+                    throw e;
+                if (e instanceof BreakSignal)
+                    throw e;
+                if (e instanceof ContinueSignal)
+                    throw e;
+                const catchEnv = new Env(env);
+                const errMsg = e instanceof Error ? e.message : String(e);
+                catchEnv.set(expr.catchVar, errMsg);
+                return evalExpr(expr.catchBody, catchEnv);
+            }
+        }
         case "IndexExpr": {
             const obj = evalExpr(expr.object, env);
             const idx = evalExpr(expr.index, env);
@@ -2786,10 +2838,11 @@ function evalExpr(expr, env) {
             return resolveAsync(val);
         }
         case "FetchExpr": {
-            return expr.targets.map(t => {
+            const results = expr.targets.map(t => {
                 const val = evalExpr(t, env);
                 return resolveAsync(val);
             });
+            return results.length === 1 ? results[0] : results;
         }
         case "BlockExpr": {
             const blockEnv = new Env(env);
@@ -2894,14 +2947,72 @@ function evalStmt(stmt, env) {
                             loopEnv.set(n, m.get(n) ?? null);
                     }
                 }
-                result = evalExpr(stmt.body, loopEnv);
+                try {
+                    result = evalExpr(stmt.body, loopEnv);
+                }
+                catch (e) {
+                    if (e instanceof BreakSignal)
+                        break;
+                    if (e instanceof ContinueSignal)
+                        continue;
+                    throw e;
+                }
             }
             return result;
         }
+        case "WhileStmt": {
+            let result = null;
+            while (isTruthy(evalExpr(stmt.condition, env))) {
+                try {
+                    result = evalExpr(stmt.body, env);
+                }
+                catch (e) {
+                    if (e instanceof BreakSignal)
+                        break;
+                    if (e instanceof ContinueSignal)
+                        continue;
+                    throw e;
+                }
+            }
+            return result;
+        }
+        case "TryCatchStmt": {
+            try {
+                return evalExpr(stmt.body, env);
+            }
+            catch (e) {
+                if (e instanceof ReturnSignal)
+                    throw e; // don't catch return/break/continue
+                if (e instanceof BreakSignal)
+                    throw e;
+                if (e instanceof ContinueSignal)
+                    throw e;
+                const catchEnv = new Env(env);
+                const errMsg = e instanceof Error ? e.message : String(e);
+                catchEnv.set(stmt.catchVar, errMsg);
+                return evalExpr(stmt.catchBody, catchEnv);
+            }
+        }
         case "DoStmt": {
             let result = null;
             do {
-                result = evalExpr(stmt.body, env);
+                try {
+                    result = evalExpr(stmt.body, env);
+                }
+                catch (e) {
+                    if (e instanceof BreakSignal) {
+                        break;
+                    }
+                    if (e instanceof ContinueSignal) {
+                        const cond = evalExpr(stmt.condition, env);
+                        if (stmt.isWhile && !isTruthy(cond))
+                            break;
+                        if (!stmt.isWhile && isTruthy(cond))
+                            break;
+                        continue;
+                    }
+                    throw e;
+                }
                 const cond = evalExpr(stmt.condition, env);
                 if (stmt.isWhile && !isTruthy(cond))
                     break;
@@ -2910,6 +3021,8 @@ function evalStmt(stmt, env) {
             } while (true);
             return result;
         }
+        case "BreakStmt": throw new BreakSignal();
+        case "ContinueStmt": throw new ContinueSignal();
         case "AssignStmt": {
             const value = evalExpr(stmt.value, env);
             env.assign(stmt.target, value);

package/dist/lexer.d.ts

@@ -34,43 +34,47 @@ export declare enum TokenType {
     Where = 32,
     Matching = 33,
     Fetch = 34,
-    Plus = 35,
-    Minus = 36,
-    Star = 37,
-    Slash = 38,
-    Percent = 39,
-    Power = 40,
-    Eq = 41,
-    Neq = 42,
-    Lt = 43,
-    Gt = 44,
-    Lte = 45,
-    Gte = 46,
-    Pipe = 47,
-    Bar = 48,
-    FatArrow = 49,
-    Arrow = 50,
-    Question = 51,
-    QuestionDot = 52,
-    Range = 53,
-    Concat = 54,
-    At = 55,
-    Hash = 56,
-    DotDotDot = 57,
-    Assign = 58,
-    LParen = 59,
-    RParen = 60,
-    LBrace = 61,
-    RBrace = 62,
-    LBracket = 63,
-    RBracket = 64,
-    Comma = 65,
-    Colon = 66,
-    Dot = 67,
-    Semicolon = 68,
-    Newline = 69,
-    Regex = 70,
-    EOF = 71
+    Break = 35,
+    Continue = 36,
+    Try = 37,
+    Catch = 38,
+    Plus = 39,
+    Minus = 40,
+    Star = 41,
+    Slash = 42,
+    Percent = 43,
+    Power = 44,
+    Eq = 45,
+    Neq = 46,
+    Lt = 47,
+    Gt = 48,
+    Lte = 49,
+    Gte = 50,
+    Pipe = 51,
+    Bar = 52,
+    FatArrow = 53,
+    Arrow = 54,
+    Question = 55,
+    QuestionDot = 56,
+    Range = 57,
+    Concat = 58,
+    At = 59,
+    Hash = 60,
+    DotDotDot = 61,
+    Assign = 62,
+    LParen = 63,
+    RParen = 64,
+    LBrace = 65,
+    RBrace = 66,
+    LBracket = 67,
+    RBracket = 68,
+    Comma = 69,
+    Colon = 70,
+    Dot = 71,
+    Semicolon = 72,
+    Newline = 73,
+    Regex = 74,
+    EOF = 75
 }
 export interface Token {
     type: TokenType;

package/dist/lexer.js

@@ -38,47 +38,51 @@ export var TokenType;
     TokenType[TokenType["Where"] = 32] = "Where";
     TokenType[TokenType["Matching"] = 33] = "Matching";
     TokenType[TokenType["Fetch"] = 34] = "Fetch";
+    TokenType[TokenType["Break"] = 35] = "Break";
+    TokenType[TokenType["Continue"] = 36] = "Continue";
+    TokenType[TokenType["Try"] = 37] = "Try";
+    TokenType[TokenType["Catch"] = 38] = "Catch";
     // Operators
-    TokenType[TokenType["Plus"] = 35] = "Plus";
-    TokenType[TokenType["Minus"] = 36] = "Minus";
-    TokenType[TokenType["Star"] = 37] = "Star";
-    TokenType[TokenType["Slash"] = 38] = "Slash";
-    TokenType[TokenType["Percent"] = 39] = "Percent";
-    TokenType[TokenType["Power"] = 40] = "Power";
-    TokenType[TokenType["Eq"] = 41] = "Eq";
-    TokenType[TokenType["Neq"] = 42] = "Neq";
-    TokenType[TokenType["Lt"] = 43] = "Lt";
-    TokenType[TokenType["Gt"] = 44] = "Gt";
-    TokenType[TokenType["Lte"] = 45] = "Lte";
-    TokenType[TokenType["Gte"] = 46] = "Gte";
-    TokenType[TokenType["Pipe"] = 47] = "Pipe";
-    TokenType[TokenType["Bar"] = 48] = "Bar";
-    TokenType[TokenType["FatArrow"] = 49] = "FatArrow";
-    TokenType[TokenType["Arrow"] = 50] = "Arrow";
-    TokenType[TokenType["Question"] = 51] = "Question";
-    TokenType[TokenType["QuestionDot"] = 52] = "QuestionDot";
-    TokenType[TokenType["Range"] = 53] = "Range";
-    TokenType[TokenType["Concat"] = 54] = "Concat";
-    TokenType[TokenType["At"] = 55] = "At";
-    TokenType[TokenType["Hash"] = 56] = "Hash";
-    TokenType[TokenType["DotDotDot"] = 57] = "DotDotDot";
-    TokenType[TokenType["Assign"] = 58] = "Assign";
+    TokenType[TokenType["Plus"] = 39] = "Plus";
+    TokenType[TokenType["Minus"] = 40] = "Minus";
+    TokenType[TokenType["Star"] = 41] = "Star";
+    TokenType[TokenType["Slash"] = 42] = "Slash";
+    TokenType[TokenType["Percent"] = 43] = "Percent";
+    TokenType[TokenType["Power"] = 44] = "Power";
+    TokenType[TokenType["Eq"] = 45] = "Eq";
+    TokenType[TokenType["Neq"] = 46] = "Neq";
+    TokenType[TokenType["Lt"] = 47] = "Lt";
+    TokenType[TokenType["Gt"] = 48] = "Gt";
+    TokenType[TokenType["Lte"] = 49] = "Lte";
+    TokenType[TokenType["Gte"] = 50] = "Gte";
+    TokenType[TokenType["Pipe"] = 51] = "Pipe";
+    TokenType[TokenType["Bar"] = 52] = "Bar";
+    TokenType[TokenType["FatArrow"] = 53] = "FatArrow";
+    TokenType[TokenType["Arrow"] = 54] = "Arrow";
+    TokenType[TokenType["Question"] = 55] = "Question";
+    TokenType[TokenType["QuestionDot"] = 56] = "QuestionDot";
+    TokenType[TokenType["Range"] = 57] = "Range";
+    TokenType[TokenType["Concat"] = 58] = "Concat";
+    TokenType[TokenType["At"] = 59] = "At";
+    TokenType[TokenType["Hash"] = 60] = "Hash";
+    TokenType[TokenType["DotDotDot"] = 61] = "DotDotDot";
+    TokenType[TokenType["Assign"] = 62] = "Assign";
     // Delimiters
-    TokenType[TokenType["LParen"] = 59] = "LParen";
-    TokenType[TokenType["RParen"] = 60] = "RParen";
-    TokenType[TokenType["LBrace"] = 61] = "LBrace";
-    TokenType[TokenType["RBrace"] = 62] = "RBrace";
-    TokenType[TokenType["LBracket"] = 63] = "LBracket";
-    TokenType[TokenType["RBracket"] = 64] = "RBracket";
-    TokenType[TokenType["Comma"] = 65] = "Comma";
-    TokenType[TokenType["Colon"] = 66] = "Colon";
-    TokenType[TokenType["Dot"] = 67] = "Dot";
-    TokenType[TokenType["Semicolon"] = 68] = "Semicolon";
-    TokenType[TokenType["Newline"] = 69] = "Newline";
+    TokenType[TokenType["LParen"] = 63] = "LParen";
+    TokenType[TokenType["RParen"] = 64] = "RParen";
+    TokenType[TokenType["LBrace"] = 65] = "LBrace";
+    TokenType[TokenType["RBrace"] = 66] = "RBrace";
+    TokenType[TokenType["LBracket"] = 67] = "LBracket";
+    TokenType[TokenType["RBracket"] = 68] = "RBracket";
+    TokenType[TokenType["Comma"] = 69] = "Comma";
+    TokenType[TokenType["Colon"] = 70] = "Colon";
+    TokenType[TokenType["Dot"] = 71] = "Dot";
+    TokenType[TokenType["Semicolon"] = 72] = "Semicolon";
+    TokenType[TokenType["Newline"] = 73] = "Newline";
     // Regex
-    TokenType[TokenType["Regex"] = 70] = "Regex";
+    TokenType[TokenType["Regex"] = 74] = "Regex";
     // Special
-    TokenType[TokenType["EOF"] = 71] = "EOF";
+    TokenType[TokenType["EOF"] = 75] = "EOF";
 })(TokenType || (TokenType = {}));
 const KEYWORDS = {
     fn: TokenType.Fn, let: TokenType.Let, mut: TokenType.Mut, type: TokenType.Type,
@@ -89,6 +93,10 @@ const KEYWORDS = {
     true: TokenType.True, false: TokenType.False, nil: TokenType.NilKw,
     and: TokenType.And, or: TokenType.Or, not: TokenType.Not,
     where: TokenType.Where, matching: TokenType.Matching, fetch: TokenType.Fetch,
+    break: TokenType.Break, continue: TokenType.Continue,
+    return: TokenType.Ret, // alias: Arc uses 'ret' but accept 'return' too
+    else: TokenType.El, // alias: Arc uses 'el' but accept 'else' too
+    try: TokenType.Try, catch: TokenType.Catch,
 };
 export function lex(source) {
     const tokens = [];
@@ -124,8 +132,8 @@ export function lex(source) {
             tokens.push(tok(TokenType.Newline, "\\n", sl, sc));
             continue;
         }
-        // Comments: # to end of line
-        if (ch === "#") {
+        // Comments: # or // to end of line
+        if (ch === "#" || (ch === "/" && peek(1) === "/")) {
             while (i < source.length && peek() !== "\n")
                 advance();
             continue;

package/dist/linter.js

@@ -343,6 +343,24 @@ export function lint(source, options) {
                 }
                 break;
             }
+            case "WhileStmt":
+                analyzeExpr(stmt.condition, scope);
+                analyzeExpr(stmt.body, scope);
+                if (stmt.body.kind === "BlockExpr" && stmt.body.stmts.length === 0) {
+                    warn("empty-block", "While loop has an empty body", stmt.loc);
+                }
+                break;
+            case "BreakStmt":
+            case "ContinueStmt":
+                break;
+            case "TryCatchStmt":
+                analyzeExpr(stmt.body, scope);
+                analyzeExpr(stmt.catchBody, scope);
+                break;
+            case "RetStmt":
+                if (stmt.value)
+                    analyzeExpr(stmt.value, scope);
+                break;
             case "DoStmt":
                 analyzeExpr(stmt.body, scope);
                 analyzeExpr(stmt.condition, scope);

package/dist/modules.js

@@ -35,10 +35,14 @@ export function resolveModule(path, basePath) {
     const relPath = resolve(dirname(basePath), modulePath);
     if (existsSync(relPath))
         return relPath;
-    // 3. Check compiler's sibling stdlib/
+    // 3. Check compiler's sibling stdlib/ (monorepo layout)
     const compilerStdlib = resolve(__dirname2, "..", "..", "stdlib", modulePath);
     if (existsSync(compilerStdlib))
         return compilerStdlib;
+    // 4. Check stdlib bundled inside the npm package (npm install -g layout)
+    const bundledStdlib = resolve(__dirname2, "..", "stdlib", modulePath);
+    if (existsSync(bundledStdlib))
+        return bundledStdlib;
     throw new Error(`Module not found: ${path.join("/")} (searched from ${basePath})`);
 }
 /**

package/dist/parser.d.ts

@@ -21,6 +21,8 @@ export declare class Parser {
     private parseAsync;
     private parseFn;
     private parseFor;
+    private parseWhile;
+    private parseTryCatch;
     private parseDo;
     private parseUse;
     private parseType;

package/dist/parser.js

@@ -52,7 +52,18 @@ export class Parser {
             case TokenType.Fn: return this.parseFn(false);
             case TokenType.Async: return this.parseAsync();
             case TokenType.For: return this.parseFor();
+            case TokenType.While: return this.parseWhile();
             case TokenType.Do: return this.parseDo();
+            case TokenType.Break: {
+                const loc = this.loc();
+                this.advance();
+                return { kind: "BreakStmt", loc };
+            }
+            case TokenType.Continue: {
+                const loc = this.loc();
+                this.advance();
+                return { kind: "ContinueStmt", loc };
+            }
             case TokenType.Use: return this.parseUse();
             case TokenType.Type: return this.parseType();
             case TokenType.Ret: return this.parseRet();
@@ -241,6 +252,22 @@ export class Parser {
         const body = this.parseBlock();
         return { kind: "ForStmt", variable, iterable, body, loc };
     }
+    parseWhile() {
+        const loc = this.loc();
+        this.expect(TokenType.While);
+        const condition = this.parseExpr(0);
+        const body = this.parseBlock();
+        return { kind: "WhileStmt", condition, body, loc };
+    }
+    parseTryCatch() {
+        const loc = this.loc();
+        this.expect(TokenType.Try);
+        const body = this.parseBlock();
+        this.expect(TokenType.Catch);
+        const catchVar = this.expect(TokenType.Ident).value;
+        const catchBody = this.parseBlock();
+        return { kind: "TryCatchStmt", body, catchVar, catchBody, loc };
+    }
     parseDo() {
         const loc = this.loc();
         this.expect(TokenType.Do);
@@ -473,14 +500,30 @@ export class Parser {
             // Postfix: member access
             if (t.type === TokenType.Dot) {
                 this.advance();
-                const prop = this.expect(TokenType.Ident).value;
+                // Allow keywords (like 'match') as property names after dot
+                const propToken = this.peek();
+                let prop;
+                if (propToken.type === TokenType.Ident || propToken.type === TokenType.Match || propToken.type === TokenType.Fn || propToken.type === TokenType.Let || propToken.type === TokenType.If || propToken.type === TokenType.For || propToken.type === TokenType.In || propToken.type === TokenType.Do || propToken.type === TokenType.While || propToken.type === TokenType.Until || propToken.type === TokenType.Use || propToken.type === TokenType.Pub || propToken.type === TokenType.Type || propToken.type === TokenType.Ret || propToken.type === TokenType.Where || propToken.type === TokenType.Matching || propToken.type === TokenType.Fetch || propToken.type === TokenType.Async || propToken.type === TokenType.Await || propToken.type === TokenType.Try || propToken.type === TokenType.Catch) {
+                    prop = this.advance().value;
+                }
+                else {
+                    prop = this.expect(TokenType.Ident).value;
+                }
                 left = { kind: "MemberExpr", object: left, property: prop, loc: left.loc };
                 continue;
             }
             // Postfix: optional chaining ?.
             if (t.type === TokenType.QuestionDot) {
                 this.advance();
-                const prop = this.expect(TokenType.Ident).value;
+                // Allow keywords as property names after ?.
+                const propToken = this.peek();
+                let prop;
+                if (propToken.type === TokenType.Ident || propToken.type === TokenType.Match || propToken.type === TokenType.Fn || propToken.type === TokenType.Let || propToken.type === TokenType.If || propToken.type === TokenType.For || propToken.type === TokenType.In || propToken.type === TokenType.Do || propToken.type === TokenType.While || propToken.type === TokenType.Until || propToken.type === TokenType.Use || propToken.type === TokenType.Pub || propToken.type === TokenType.Type || propToken.type === TokenType.Ret || propToken.type === TokenType.Where || propToken.type === TokenType.Matching || propToken.type === TokenType.Fetch || propToken.type === TokenType.Async || propToken.type === TokenType.Await || propToken.type === TokenType.Try || propToken.type === TokenType.Catch) {
+                    prop = this.advance().value;
+                }
+                else {
+                    prop = this.expect(TokenType.Ident).value;
+                }
                 left = { kind: "OptionalMemberExpr", object: left, property: prop, loc: left.loc };
                 continue;
             }
@@ -660,24 +703,61 @@ export class Parser {
             const body = this.parseBlock();
             return { kind: "AsyncExpr", body, loc };
         }
+        // Anonymous function expression: fn(params) { body } or fn(params) => expr
+        if (t.type === TokenType.Fn) {
+            this.advance();
+            this.expect(TokenType.LParen);
+            const params = [];
+            while (!this.at(TokenType.RParen)) {
+                params.push(this.expect(TokenType.Ident).value);
+                if (this.at(TokenType.Comma))
+                    this.advance();
+            }
+            this.expect(TokenType.RParen);
+            if (this.at(TokenType.FatArrow)) {
+                this.advance();
+                const body = this.parseExpr();
+                return { kind: "LambdaExpr", params, body, loc };
+            }
+            const body = this.parseBlock();
+            return { kind: "LambdaExpr", params, body, loc };
+        }
+        // Try/catch expression: try { body } catch e { handler }
+        if (t.type === TokenType.Try) {
+            this.advance();
+            const body = this.parseBlock();
+            if (this.at(TokenType.Catch)) {
+                this.expect(TokenType.Catch);
+                const catchVar = this.expect(TokenType.Ident).value;
+                const catchBody = this.parseBlock();
+                return { kind: "TryCatchExpr", body, catchVar, catchBody, loc };
+            }
+            // Plain try expression (wraps in Result)
+            return { kind: "TryExpr", expr: body, loc };
+        }
         // Await expression: await expr
         if (t.type === TokenType.Await) {
             this.advance();
             const expr = this.parseExpr(8); // high precedence
             return { kind: "AwaitExpr", expr, loc };
         }
-        // Fetch expression: fetch [expr1, expr2, ...]
+        // Fetch expression: fetch @GET "url" or fetch [expr1, expr2, ...]
         if (t.type === TokenType.Fetch) {
             this.advance();
-            this.expect(TokenType.LBracket);
-            const targets = [];
-            while (!this.at(TokenType.RBracket)) {
-                targets.push(this.parseExpr());
-                if (this.at(TokenType.Comma))
-                    this.advance();
+            if (this.at(TokenType.LBracket)) {
+                this.advance();
+                const targets = [];
+                while (!this.at(TokenType.RBracket)) {
+                    targets.push(this.parseExpr());
+                    if (this.at(TokenType.Comma))
+                        this.advance();
+                }
+                this.expect(TokenType.RBracket);
+                return { kind: "FetchExpr", targets, loc };
             }
-            this.expect(TokenType.RBracket);
-            return { kind: "FetchExpr", targets, loc };
+            // Single target: fetch @GET "url"
+            const target = this.parseExpr();
+            return { kind: "FetchExpr", targets: [target], loc };
         }
         // Tool call: @GET "url" or @ident(args)
         if (t.type === TokenType.At) {