arc-lang 0.6.2 → 0.6.3

package/dist/ast.d.ts

@@ -2,7 +2,7 @@ export interface Loc {
     line: number;
     col: number;
 }
-export type Expr = IntLiteral | FloatLiteral | BoolLiteral | NilLiteral | StringLiteral | StringInterp | Identifier | BinaryExpr | UnaryExpr | CallExpr | MemberExpr | IndexExpr | PipelineExpr | IfExpr | MatchExpr | LambdaExpr | ListLiteral | MapLiteral | ListComprehension | ToolCallExpr | RangeExpr | BlockExpr | AsyncExpr | AwaitExpr | FetchExpr | SpreadExpr | OptionalMemberExpr | TryExpr;
+export type Expr = IntLiteral | FloatLiteral | BoolLiteral | NilLiteral | StringLiteral | StringInterp | Identifier | BinaryExpr | UnaryExpr | CallExpr | MemberExpr | IndexExpr | PipelineExpr | IfExpr | MatchExpr | LambdaExpr | ListLiteral | MapLiteral | ListComprehension | ToolCallExpr | RangeExpr | BlockExpr | AsyncExpr | AwaitExpr | FetchExpr | SpreadExpr | OptionalMemberExpr | TryExpr | TryCatchExpr;
 export interface IntLiteral {
     kind: "IntLiteral";
     value: number;
@@ -170,6 +170,13 @@ export interface TryExpr {
     expr: Expr;
     loc: Loc;
 }
+export interface TryCatchExpr {
+    kind: "TryCatchExpr";
+    body: Expr;
+    catchVar: string;
+    catchBody: Expr;
+    loc: Loc;
+}
 export type Pattern = WildcardPattern | LiteralPattern | BindingPattern | ArrayPattern | OrPattern | ConstructorPattern;
 export interface WildcardPattern {
     kind: "WildcardPattern";
@@ -201,7 +208,7 @@ export interface ConstructorPattern {
     args: Pattern[];
     loc: Loc;
 }
-export type Stmt = LetStmt | FnStmt | ForStmt | DoStmt | ExprStmt | UseStmt | TypeStmt | AssignStmt | MemberAssignStmt | IndexAssignStmt | RetStmt;
+export type Stmt = LetStmt | FnStmt | ForStmt | DoStmt | WhileStmt | ExprStmt | UseStmt | TypeStmt | AssignStmt | MemberAssignStmt | IndexAssignStmt | RetStmt | BreakStmt | ContinueStmt | TryCatchStmt;
 export interface AssignStmt {
     kind: "AssignStmt";
     target: string;
@@ -270,6 +277,27 @@ export interface DoStmt {
     isWhile: boolean;
     loc: Loc;
 }
+export interface WhileStmt {
+    kind: "WhileStmt";
+    condition: Expr;
+    body: Expr;
+    loc: Loc;
+}
+export interface BreakStmt {
+    kind: "BreakStmt";
+    loc: Loc;
+}
+export interface ContinueStmt {
+    kind: "ContinueStmt";
+    loc: Loc;
+}
+export interface TryCatchStmt {
+    kind: "TryCatchStmt";
+    body: Expr;
+    catchVar: string;
+    catchBody: Expr;
+    loc: Loc;
+}
 export interface ExprStmt {
     kind: "ExprStmt";
     expr: Expr;

package/dist/build.js

@@ -127,7 +127,7 @@ export function newProject(name, parentDir) {
         "dev-dependencies": {},
     };
     writeFileSync(resolve(projectDir, "arc.toml"), serializeArcToml(toml));
-    writeFileSync(resolve(projectDir, "src", "main.arc"), `fn main() {\n  let msg = "Hello from ${name}!"\n  print(msg)\n}\n`);
+    writeFileSync(resolve(projectDir, "src", "main.arc"), `# Hello from ${name}!\nlet msg = "Hello from ${name}!"\nprint(msg)\n`);
     writeFileSync(resolve(projectDir, "tests", "main.test.arc"), `fn test_main() {\n  let x = 1 + 1\n  print(x)\n}\n`);
     writeFileSync(resolve(projectDir, "README.md"), `# ${name}\n\nAn Arc project.\n\n## Getting Started\n\n\`\`\`bash\narc build\narc run\n\`\`\`\n`);
     console.log(`Created project '${name}'`);

package/dist/index.js

@@ -101,6 +101,108 @@ else if (command === "pkg") {
         process.exit(1);
     }
 }
+else if (command === "builtins") {
+    console.log("Arc Built-in Functions\n");
+    console.log("I/O:");
+    console.log("  print(...values)          Print values to stdout\n");
+    console.log("Type Conversion:");
+    console.log("  int(v)                    Convert to integer (throws on bad input)");
+    console.log("  float(v)                  Convert to float (throws on bad input)");
+    console.log("  str(v)                    Convert to string");
+    console.log("  bool(v)                   Convert to boolean");
+    console.log("  type_of(v)                Get type: \"int\" \"float\" \"string\" \"bool\" \"list\" \"map\" \"fn\" \"nil\"\n");
+    console.log("Strings:");
+    console.log("  len(s)                    Length (codepoints, not bytes)");
+    console.log("  trim(s)                   Strip whitespace");
+    console.log("  upper(s) / lower(s)       Case conversion");
+    console.log("  split(s, sep)             Split into list");
+    console.log("  join(list, sep)           Join list into string");
+    console.log("  replace(s, old, new)      Replace all occurrences");
+    console.log("  contains(s, sub)          Check substring");
+    console.log("  starts(s, prefix)         Starts with");
+    console.log("  ends(s, suffix)           Ends with");
+    console.log("  repeat(s, n)              Repeat string n times");
+    console.log("  chars(s)                  Split into character list");
+    console.log("  slice(s, start, end?)     Substring");
+    console.log("  index_of(s, sub)          Find index (nil if not found)");
+    console.log("  ord(s)                    Char to code point");
+    console.log("  chr(n)                    Code point to char");
+    console.log("  char_at(s, i)             Character at index\n");
+    console.log("Lists:");
+    console.log("  len(list)                 Length");
+    console.log("  map(list, fn)             Transform each element");
+    console.log("  filter(list, fn)          Keep elements matching predicate");
+    console.log("  reduce(list, fn, init)    Fold left");
+    console.log("  fold(list, init, fn)      Fold (init-first arg order)");
+    console.log("  find(list, fn)            First matching element");
+    console.log("  any(list, fn)             Any element matches?");
+    console.log("  all(list, fn)             All elements match?");
+    console.log("  sort(list)                Sort (numbers or strings)");
+    console.log("  head(list)                First element");
+    console.log("  tail(list)                All but first");
+    console.log("  last(list)                Last element");
+    console.log("  reverse(list)             Reverse");
+    console.log("  take(list, n)             First n elements");
+    console.log("  drop(list, n)             Skip first n");
+    console.log("  flat(list)                Flatten nested lists");
+    console.log("  zip(a, b)                 Zip two lists");
+    console.log("  enumerate(list)           Add indices: [[0,a],[1,b],...]");
+    console.log("  push(list, item)          Append (returns new list)");
+    console.log("  concat(a, b)              Concatenate lists");
+    console.log("  sum(list)                 Sum numbers");
+    console.log("  range(a, b)               Generate [a, a+1, ..., b-1]\n");
+    console.log("Maps:");
+    console.log("  keys(map)                 Get keys as list");
+    console.log("  values(map)               Get values as list");
+    console.log("  entries(map)              Key-value pairs\n");
+    console.log("Math:");
+    console.log("  abs(n)                    Absolute value");
+    console.log("  min(...) / max(...)       Min/max (args or list)");
+    console.log("  round(n)                  Round to integer\n");
+    console.log("Other:");
+    console.log("  assert(cond, msg?)        Assert truth (throws on false)");
+    console.log("  time_ms()                 Unix timestamp in milliseconds\n");
+    console.log("Operators:  +  -  *  /  %  **  ++  ==  !=  <  >  <=  >=  and  or  not  |>  ..  ?.");
+    console.log("Strings:    \"text {expr}\" (interpolation)   \"ha\" * 3 (repetition)");
+    console.log("Comments:   # or //");
+    console.log("Errors:     try { ... } catch e { ... }\n");
+    console.log("Stdlib:     arc builtins --modules    (list all standard library modules)");
+    if (args.includes("--modules")) {
+        console.log("\nStandard Library Modules:  (import with: use <module>)\n");
+        const mods = [
+            ["math", "sqrt, pow, ceil, floor, clamp, PI, E, sin, cos, log, 25 functions"],
+            ["strings", "pad_left, pad_right, capitalize, words"],
+            ["collections", "group_by, chunk, flatten, zip_with, partition, sort_by, unique"],
+            ["map", "merge, map_values, filter_map, from_pairs, pick, omit"],
+            ["io", "read_file, write_file, read_lines, exists, append"],
+            ["http", "get, post, put, delete — real HTTP requests"],
+            ["json", "to_json, from_json, pretty, get_path"],
+            ["csv", "parse_csv, to_csv, parse_csv_headers"],
+            ["regex", "match, find, test, replace, split, capture"],
+            ["datetime", "now, today, parse, format, add_days, diff_days"],
+            ["os", "cwd, list_dir, mkdir, exec, platform, env, remove, copy"],
+            ["env", "get, set, has, all — environment variables"],
+            ["crypto", "sha256, sha512, hmac_sha256, uuid, random_bytes"],
+            ["error", "try_catch, try_finally, throw, retry, assert"],
+            ["result", "ok, err, is_ok, unwrap, map_result, try_fn"],
+            ["net", "ws_connect, tcp_connect, dns_lookup, base64_encode"],
+            ["yaml", "parse, stringify"],
+            ["toml", "parse, stringify"],
+            ["html", "parse, create_element, to_html"],
+            ["path", "join, dirname, basename, extname"],
+            ["log", "info, warn, error, debug"],
+            ["store", "get, set, delete — persistent key-value storage"],
+            ["test", "describe, it, expect_eq, run_tests"],
+            ["prompt", "template, count_tokens, window"],
+            ["embed", "similarity, cosine, search"],
+            ["llm", "chat, complete — multi-provider LLM API"],
+        ];
+        for (const [name, desc] of mods) {
+            console.log(`  ${name.padEnd(14)} ${desc}`);
+        }
+    }
+    process.exit(0);
+}
 else if (command === "help" || command === "--help" || command === "-h" || !command || !file) {
     console.log(`Arc ${ARC_VERSION} — A programming language designed by AI agents, for AI agents.\n`);
     console.log("Usage: arc <command> [options]\n");
@@ -117,6 +219,8 @@ else if (command === "help" || command === "--help" || command === "-h" || !comm
     console.log("  build                   Build the current project");
     console.log("  test                    Run project tests");
     console.log("  new <name>              Create a new project");
+    console.log("  builtins                List all built-in functions");
+    console.log("  builtins --modules      List all standard library modules");
     console.log("  pkg <sub>               Package manager (init|add|remove|list|install)");
     console.log("  version                 Print version info");
     console.log("\nOptions:");

package/dist/interpreter.js

@@ -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/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;