arc-lang 0.5.2 → 0.5.4

package/README.md

@@ -96,7 +96,7 @@ Plus many built-in functions available without imports: `map`, `filter`, `reduce
 
 ## Status
 
-🚀 **In Active Development** — Arc has a working compiler (lexer, parser, IR, optimizer, JS/WAT codegen), interpreter, REPL, 11 stdlib modules, LSP, VS Code extension, package manager, build system, formatter, linter, security sandbox, rich error reporting, benchmarking framework, and migration tools. 504+ tests passing.
+🚀 **In Active Development** — Arc has a working compiler (lexer, parser, IR, optimizer, JS/WAT codegen), interpreter, REPL, 17 stdlib modules, LSP, VS Code extension, package manager, build system, formatter, linter, security sandbox, rich error reporting, benchmarking framework, and migration tools. 508+ tests passing.
 
 Current phase: **Phase 6 — Community & Adoption**
 

package/dist/ast.d.ts

@@ -177,7 +177,7 @@ export interface OrPattern {
     patterns: Pattern[];
     loc: Loc;
 }
-export type Stmt = LetStmt | FnStmt | ForStmt | DoStmt | ExprStmt | UseStmt | TypeStmt | AssignStmt | MemberAssignStmt | IndexAssignStmt;
+export type Stmt = LetStmt | FnStmt | ForStmt | DoStmt | ExprStmt | UseStmt | TypeStmt | AssignStmt | MemberAssignStmt | IndexAssignStmt | RetStmt;
 export interface AssignStmt {
     kind: "AssignStmt";
     target: string;
@@ -198,6 +198,11 @@ export interface IndexAssignStmt {
     value: Expr;
     loc: Loc;
 }
+export interface RetStmt {
+    kind: "RetStmt";
+    value?: Expr;
+    loc: Loc;
+}
 export interface LetStmt {
     kind: "LetStmt";
     name: string | DestructureTarget;

package/dist/build.js

@@ -127,8 +127,8 @@ export function newProject(name, parentDir) {
         "dev-dependencies": {},
     };
     writeFileSync(resolve(projectDir, "arc.toml"), serializeArcToml(toml));
-    writeFileSync(resolve(projectDir, "src", "main.arc"), `fn main() do\n  let msg = "Hello from ${name}!"\nend\n`);
-    writeFileSync(resolve(projectDir, "tests", "main.test.arc"), `fn test_main() do\n  let x = 1 + 1\nend\n`);
+    writeFileSync(resolve(projectDir, "src", "main.arc"), `fn main() {\n  let msg = "Hello from ${name}!"\n  print(msg)\n}\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}'`);
     console.log(`  ${name}/arc.toml`);

package/dist/codegen-js.js

@@ -9,7 +9,8 @@ export function generateJS(module) {
     lines.push(`  len(a) { return Array.isArray(a) ? a.length : typeof a === "string" ? a.length : 0; },`);
     lines.push(`  str(v) { return String(v); },`);
     lines.push(`  push(arr, v) { arr.push(v); return arr; },`);
-    lines.push(`  print(v) { console.log(typeof v === "object" && v !== null ? JSON.stringify(v) : v); },`);
+    lines.push(`  __toStr(v) { if (v === null) return "nil"; if (typeof v === "boolean") return v ? "true" : "false"; if (typeof v === "number" || typeof v === "string") return String(v); if (Array.isArray(v)) return "[" + v.map(x => this.__toStr(x)).join(", ") + "]"; if (v && v.__map) { const entries = [...v.entries.entries()].map(([k, val]) => k + ": " + this.__toStr(val)); return "{" + entries.join(", ") + "}"; } return String(v); },`);
+    lines.push(`  print(v) { console.log(this.__toStr(v)); },`);
     lines.push(`  head(a) { return a[0]; },`);
     lines.push(`  tail(a) { return a.slice(1); },`);
     lines.push(`  map(a, f) { return a.map(f); },`);
@@ -34,6 +35,9 @@ export function generateJS(module) {
     lines.push(`  replace(s, old, nw) { return s.replaceAll(old, nw); },`);
     lines.push(`  uppercase(s) { return s.toUpperCase(); },`);
     lines.push(`  lowercase(s) { return s.toLowerCase(); },`);
+    lines.push(`  upper(s) { return s.toUpperCase(); },`);
+    lines.push(`  lower(s) { return s.toLowerCase(); },`);
+    lines.push(`  type_of(v) { if (v === null) return "nil"; if (typeof v === "boolean") return "bool"; if (typeof v === "number") return Number.isInteger(v) ? "int" : "float"; if (typeof v === "string") return "string"; if (Array.isArray(v)) return "list"; if (v && v.__map) return "map"; return "unknown"; },`);
     lines.push(`  sum(a) { return a.reduce((s, x) => s + x, 0); },`);
     lines.push(`  flat(a) { return a.flat(); },`);
     lines.push(`  zip(a, b) { return a.map((x, i) => [x, b[i]]); },`);
@@ -74,9 +78,71 @@ function emitFunction(fn, baseIndent = "") {
 }
 function emitBlock(block, indent) {
     const lines = [];
-    for (const instr of block.instrs) {
-        lines.push(indent + emitInstr(instr));
+    const instrs = block.instrs;
+    const sections = [];
+    let currentSection = { label: "__start", instrs: [] };
+    sections.push(currentSection);
+    for (const instr of instrs) {
+        if (instr.op === "label") {
+            currentSection = { label: instr.name, instrs: [] };
+            sections.push(currentSection);
+        }
+        else {
+            currentSection.instrs.push(instr);
+        }
     }
+    // If no labels exist, emit linearly (simple case)
+    if (sections.length === 1) {
+        for (const instr of instrs) {
+            lines.push(indent + emitInstr(instr));
+        }
+        return lines;
+    }
+    // Use a state-machine approach with a __pc variable and a while/switch loop
+    // to properly handle branches and jumps
+    const labelToIdx = new Map();
+    for (let i = 0; i < sections.length; i++) {
+        labelToIdx.set(sections[i].label, i);
+    }
+    lines.push(`${indent}var __pc = 0;`);
+    lines.push(`${indent}__control: while (true) {`);
+    lines.push(`${indent}  switch (__pc) {`);
+    for (let i = 0; i < sections.length; i++) {
+        const section = sections[i];
+        lines.push(`${indent}    case ${i}: /* ${section.label} */`);
+        for (const instr of section.instrs) {
+            if (instr.op === "jump") {
+                const target = labelToIdx.get(instr.target);
+                if (target !== undefined) {
+                    lines.push(`${indent}      __pc = ${target}; continue __control;`);
+                }
+            }
+            else if (instr.op === "branch") {
+                const ifTrue = labelToIdx.get(instr.ifTrue);
+                const ifFalse = labelToIdx.get(instr.ifFalse);
+                lines.push(`${indent}      if (${S(instr.cond)}) { __pc = ${ifTrue}; } else { __pc = ${ifFalse}; } continue __control;`);
+            }
+            else if (instr.op === "ret") {
+                lines.push(`${indent}      ` + emitInstr(instr));
+            }
+            else {
+                lines.push(`${indent}      ` + emitInstr(instr));
+            }
+        }
+        // Fall through to next section if no jump/branch/ret at end
+        const lastInstr = section.instrs[section.instrs.length - 1];
+        if (!lastInstr || (lastInstr.op !== "jump" && lastInstr.op !== "branch" && lastInstr.op !== "ret")) {
+            if (i + 1 < sections.length) {
+                lines.push(`${indent}      __pc = ${i + 1}; continue __control;`);
+            }
+            else {
+                lines.push(`${indent}      break __control;`);
+            }
+        }
+    }
+    lines.push(`${indent}    default: break __control;`);
+    lines.push(`${indent}  }`);
+    lines.push(`${indent}}`);
     return lines;
 }
 function emitInstr(instr) {
@@ -90,7 +156,13 @@ function emitInstr(instr) {
             return `var ${S(instr.dest)} = ${S(instr.name)};`;
         case "store":
             if (instr.src.startsWith("@fn:")) {
-                return `var ${S(instr.name)} = ${S(instr.src.slice(4))};`;
+                const fnName = instr.src.slice(4);
+                // If storing a function reference to a variable with the same name,
+                // the hoisted function definition already provides it — skip redundant var
+                if (S(instr.name) === S(fnName)) {
+                    return `/* ${S(instr.name)} = ${S(fnName)} (hoisted) */`;
+                }
+                return `var ${S(instr.name)} = ${S(fnName)};`;
             }
             return `var ${S(instr.name)} = ${S(instr.src)};`;
         case "binop":
@@ -102,7 +174,7 @@ function emitInstr(instr) {
         case "toolcall":
             return `var ${S(instr.dest)} = await fetch(${S(instr.url)}, { method: ${JSON.stringify(instr.method)}${instr.body ? `, body: JSON.stringify(${S(instr.body)})` : ""} }).then(r => r.json());`;
         case "field":
-            return `var ${S(instr.dest)} = (${S(instr.obj)} && ${S(instr.obj)}.__map) ? ${S(instr.obj)}.entries.get(${JSON.stringify(instr.prop)}) : ${S(instr.obj)}[${JSON.stringify(instr.prop)}];`;
+            return `var ${S(instr.dest)} = (${S(instr.obj)} == null) ? null : (${S(instr.obj)}.__map) ? ${S(instr.obj)}.entries.get(${JSON.stringify(instr.prop)}) : ${S(instr.obj)}[${JSON.stringify(instr.prop)}];`;
         case "index":
             return `var ${S(instr.dest)} = ${S(instr.obj)}[${S(instr.idx)}];`;
         case "setfield":
@@ -155,7 +227,8 @@ function emitCall(fn, args) {
         "range", "keys", "values", "type", "abs", "max", "min", "floor", "ceil",
         "round", "sort", "reverse", "contains", "join", "split", "trim", "replace",
         "uppercase", "lowercase", "sum", "flat", "zip", "enumerate", "slice",
-        "append", "concat", "unique", "int", "float", "__await", "__fetch_parallel"
+        "append", "concat", "unique", "int", "float", "__await", "__fetch_parallel",
+        "upper", "lower", "type_of", "__toStr"
     ];
     if (builtins.includes(fn)) {
         return `__arc_runtime.${fn}(${args.join(", ")})`;

package/dist/formatter.js

@@ -141,15 +141,39 @@ export function format(source, options) {
             }
             case "IfExpr": {
                 const cond = formatExpr(expr.condition, depth);
-                const then = formatBlockExpr(expr.then, depth);
+                const thenInline = formatBlockExpr(expr.then, depth);
                 if (expr.else_) {
+                    let elInline;
                     if (expr.else_.kind === "IfExpr") {
-                        return `if ${cond} ${then} el ${formatExpr(expr.else_, depth)}`;
+                        elInline = formatExpr(expr.else_, depth);
                     }
-                    const el = formatBlockExpr(expr.else_, depth);
-                    return `if ${cond} ${then} el ${el}`;
+                    else {
+                        elInline = formatBlockExpr(expr.else_, depth);
+                    }
+                    const single = `if ${cond} ${thenInline} el ${elInline}`;
+                    if (single.length + depth * opts.indentSize <= opts.maxLineLength) {
+                        return single;
+                    }
+                    // Force multi-line blocks when single-line is too long
+                    const thenMulti = expr.then.kind === "BlockExpr"
+                        ? formatBlockMultiline(expr.then, depth)
+                        : thenInline;
+                    if (expr.else_.kind === "IfExpr") {
+                        return `if ${cond} ${thenMulti} el ${formatExpr(expr.else_, depth)}`;
+                    }
+                    const elMulti = expr.else_.kind === "BlockExpr"
+                        ? formatBlockMultiline(expr.else_, depth)
+                        : elInline;
+                    return `if ${cond} ${thenMulti} el ${elMulti}`;
+                }
+                const single = `if ${cond} ${thenInline}`;
+                if (single.length + depth * opts.indentSize <= opts.maxLineLength) {
+                    return single;
                 }
-                return `if ${cond} ${then}`;
+                const thenMulti = expr.then.kind === "BlockExpr"
+                    ? formatBlockMultiline(expr.then, depth)
+                    : thenInline;
+                return `if ${cond} ${thenMulti}`;
             }
             case "MatchExpr": {
                 const subject = formatExpr(expr.subject, depth);
@@ -218,6 +242,12 @@ export function format(source, options) {
             return formatBlockInline(expr, depth);
         return formatExpr(expr, depth);
     }
+    function formatBlockMultiline(block, depth) {
+        if (block.stmts.length === 0)
+            return "{}";
+        const body = block.stmts.map(s => `${indent(depth + 1)}${formatStmtStr(s, depth + 1)}`).join('\n');
+        return `{\n${body}\n${indent(depth)}}`;
+    }
     function formatBlockInline(block, depth) {
         if (block.stmts.length === 0)
             return "{}";
@@ -315,6 +345,8 @@ export function format(source, options) {
                 return `${formatExpr(stmt.object, depth)}.${stmt.property} = ${formatExpr(stmt.value, depth)}`;
             case "IndexAssignStmt":
                 return `${formatExpr(stmt.object, depth)}[${formatExpr(stmt.index, depth)}] = ${formatExpr(stmt.value, depth)}`;
+            default:
+                return `/* unknown stmt: ${stmt.kind} */`;
         }
     }
     // Emit top-level statements with comments and blank lines between declarations

package/dist/interpreter.js

@@ -107,6 +107,15 @@ function makePrelude(env) {
             }
             return acc;
         },
+        fold: (list, init, fn) => {
+            if (!Array.isArray(list))
+                throw new Error("fold expects a list");
+            let acc = init;
+            for (let i = 0; i < list.length; i++) {
+                acc = callFn(fn, [acc, list[i]]);
+            }
+            return acc;
+        },
         sort: (list) => {
             if (!Array.isArray(list))
                 throw new Error("sort expects a list");
@@ -243,6 +252,13 @@ function makePrelude(env) {
         env.set(name, fn);
     }
 }
+// Return signal — thrown to unwind the stack on `ret`
+class ReturnSignal {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}
 // Evaluate expression in tail position — returns TCOSignal for self-recursive tail calls
 function evalExprTCO(expr, env, fnName) {
     // Only handle tail-position expressions specially
@@ -314,11 +330,24 @@ function evalExpr(expr, env) {
             const left = evalExpr(expr.left, env);
             const right = evalExpr(expr.right, env);
             switch (expr.op) {
-                case "+": return left + right;
+                case "+": {
+                    if (typeof left === "string" || typeof right === "string") {
+                        return toStr(left) + toStr(right);
+                    }
+                    return left + right;
+                }
                 case "-": return left - right;
                 case "*": return left * right;
-                case "/": return left / right;
-                case "%": return left % right;
+                case "/": {
+                    if (right === 0)
+                        throw new Error(`Division by zero at line ${expr.loc.line}`);
+                    return left / right;
+                }
+                case "%": {
+                    if (right === 0)
+                        throw new Error(`Modulo by zero at line ${expr.loc.line}`);
+                    return left % right;
+                }
                 case "**": return Math.pow(left, right);
                 case "==": return left === right;
                 case "!=": return left !== right;
@@ -353,18 +382,28 @@ function evalExpr(expr, env) {
                 let fn = callee;
                 // Tail call optimization loop: if the function body resolves to
                 // a tail call back to itself, reuse the frame instead of recursing
-                tailLoop: while (true) {
-                    const fnEnv = new Env(fn.closure);
-                    fn.params.forEach((p, i) => fnEnv.set(p, args[i] ?? null));
-                    const bodyResult = evalExprTCO(fn.body, fnEnv, fn.name);
-                    if (bodyResult && typeof bodyResult === "object" && "__tco" in bodyResult) {
-                        const tco = bodyResult;
-                        args = tco.args;
-                        // fn stays the same — it's a self-recursive tail call
-                        continue tailLoop;
+                try {
+                    tailLoop: while (true) {
+                        const fnEnv = new Env(fn.closure);
+                        fn.params.forEach((p, i) => fnEnv.set(p, args[i] ?? null));
+                        const bodyResult = evalExprTCO(fn.body, fnEnv, fn.name);
+                        if (bodyResult && typeof bodyResult === "object" && "__tco" in bodyResult) {
+                            const tco = bodyResult;
+                            args = tco.args;
+                            // fn stays the same — it's a self-recursive tail call
+                            continue tailLoop;
+                        }
+                        result = bodyResult;
+                        break;
+                    }
+                }
+                catch (e) {
+                    if (e instanceof ReturnSignal) {
+                        result = e.value;
+                    }
+                    else {
+                        throw e;
                     }
-                    result = bodyResult;
-                    break;
                 }
             }
             else {
@@ -375,6 +414,8 @@ function evalExpr(expr, env) {
         }
         case "MemberExpr": {
             const obj = evalExpr(expr.object, env);
+            if (obj === null)
+                return null;
             if (obj && typeof obj === "object" && "__map" in obj) {
                 return obj.entries.get(expr.property) ?? null;
             }
@@ -615,6 +656,10 @@ function evalStmt(stmt, env) {
             }
             throw new Error(`Cannot assign index on ${toStr(obj)}`);
         }
+        case "RetStmt": {
+            const value = stmt.value ? evalExpr(stmt.value, env) : null;
+            throw new ReturnSignal(value);
+        }
         case "ExprStmt": return evalExpr(stmt.expr, env);
         case "UseStmt": {
             // Module imports handled by interpretWithFile; no-op if no file context

package/dist/ir.d.ts

@@ -112,9 +112,15 @@ export declare class IRGenerator {
     private labelCount;
     private functions;
     private currentInstrs;
+    private scopeStack;
+    private scopeCount;
     private temp;
     private label;
     private emit;
+    private pushScope;
+    private popScope;
+    private defineVar;
+    private resolveVar;
     generateIR(program: AST.Program): IRModule;
     private lowerStmt;
     private lowerExpr;

package/dist/ir.js

@@ -7,6 +7,8 @@ export class IRGenerator {
     labelCount = 0;
     functions = [];
     currentInstrs = [];
+    scopeStack = [new Map()];
+    scopeCount = 0;
     temp() {
         return `%${this.tempCount++}`;
     }
@@ -16,6 +18,38 @@ export class IRGenerator {
     emit(instr) {
         this.currentInstrs.push(instr);
     }
+    pushScope() {
+        this.scopeStack.push(new Map());
+    }
+    popScope() {
+        this.scopeStack.pop();
+    }
+    defineVar(name) {
+        const scope = this.scopeStack[this.scopeStack.length - 1];
+        // Check if already defined in ANY scope (including this one)
+        let existsInAnyScope = false;
+        for (let i = this.scopeStack.length - 1; i >= 0; i--) {
+            if (this.scopeStack[i].has(name)) {
+                existsInAnyScope = true;
+                break;
+            }
+        }
+        if (existsInAnyScope) {
+            const mangled = `${name}__s${this.scopeCount++}`;
+            scope.set(name, mangled);
+            return mangled;
+        }
+        scope.set(name, name);
+        return name;
+    }
+    resolveVar(name) {
+        for (let i = this.scopeStack.length - 1; i >= 0; i--) {
+            const v = this.scopeStack[i].get(name);
+            if (v !== undefined)
+                return v;
+        }
+        return name;
+    }
     generateIR(program) {
         this.functions = [];
         this.currentInstrs = [];
@@ -35,7 +69,8 @@ export class IRGenerator {
             case "LetStmt": {
                 const val = this.lowerExpr(stmt.value);
                 if (typeof stmt.name === "string") {
-                    this.emit({ op: "store", name: stmt.name, src: val });
+                    const mangled = this.defineVar(stmt.name);
+                    this.emit({ op: "store", name: mangled, src: val });
                 }
                 else {
                     // Destructuring — store temp then extract fields
@@ -50,14 +85,21 @@ export class IRGenerator {
                             this.emit({ op: "const", dest: idx, value: i });
                             this.emit({ op: "index", dest, obj: val, idx });
                         }
-                        this.emit({ op: "store", name: dt.names[i], src: dest });
+                        const mangled = this.defineVar(dt.names[i]);
+                        this.emit({ op: "store", name: mangled, src: dest });
                     }
                 }
                 break;
             }
             case "FnStmt": {
                 const savedInstrs = this.currentInstrs;
+                const savedScope = this.scopeStack;
                 this.currentInstrs = [];
+                // Function gets its own scope with params
+                this.scopeStack = [new Map()];
+                for (const p of stmt.params) {
+                    this.defineVar(p);
+                }
                 // Lower function body
                 const result = this.lowerExpr(stmt.body);
                 this.emit({ op: "ret", value: result });
@@ -67,8 +109,10 @@ export class IRGenerator {
                     blocks: [{ label: "entry", instrs: this.currentInstrs }],
                 });
                 this.currentInstrs = savedInstrs;
+                this.scopeStack = savedScope;
                 // Store function reference in main scope
-                this.emit({ op: "store", name: stmt.name, src: `@fn:${stmt.name}` });
+                const fnMangled = this.defineVar(stmt.name);
+                this.emit({ op: "store", name: fnMangled, src: `@fn:${stmt.name}` });
                 break;
             }
             case "ForStmt": {
@@ -89,10 +133,13 @@ export class IRGenerator {
                 this.emit({ op: "binop", dest: cond, operator: "<", left: counter, right: lenTemp });
                 this.emit({ op: "branch", cond, ifTrue: bodyLabel, ifFalse: endLabel });
                 this.emit({ op: "label", name: bodyLabel });
+                this.pushScope();
                 const elem = this.temp();
                 this.emit({ op: "index", dest: elem, obj: iter, idx: counter });
-                this.emit({ op: "store", name: stmt.variable, src: elem });
+                const loopVarName = this.defineVar(stmt.variable);
+                this.emit({ op: "store", name: loopVarName, src: elem });
                 this.lowerExpr(stmt.body);
+                this.popScope();
                 const next = this.temp();
                 const one = this.temp();
                 this.emit({ op: "const", dest: one, value: 1 });
@@ -122,7 +169,7 @@ export class IRGenerator {
             }
             case "AssignStmt": {
                 const val = this.lowerExpr(stmt.value);
-                this.emit({ op: "store", name: stmt.target, src: val });
+                this.emit({ op: "store", name: this.resolveVar(stmt.target), src: val });
                 break;
             }
             case "MemberAssignStmt": {
@@ -200,7 +247,7 @@ export class IRGenerator {
             }
             case "Identifier": {
                 const dest = this.temp();
-                this.emit({ op: "load", dest, name: expr.name });
+                this.emit({ op: "load", dest, name: this.resolveVar(expr.name) });
                 return dest;
             }
             case "BinaryExpr": {
@@ -303,18 +350,23 @@ export class IRGenerator {
                     // Lower pattern to condition
                     const cond = this.lowerPattern(arm.pattern, subject);
                     if (arm.guard) {
-                        // Pattern match AND guard
+                        // For guards, we need to bind pattern variables BEFORE evaluating the guard
+                        // because the guard may reference bound variables (e.g., `n if n > 10`)
+                        const guardLabel = this.label("match_guard");
+                        this.emit({ op: "branch", cond, ifTrue: guardLabel, ifFalse: nextLabel });
+                        this.emit({ op: "label", name: guardLabel });
+                        this.bindPattern(arm.pattern, subject);
                         const guardCond = this.lowerExpr(arm.guard);
-                        const combined = this.temp();
-                        this.emit({ op: "binop", dest: combined, operator: "and", left: cond, right: guardCond });
-                        this.emit({ op: "branch", cond: combined, ifTrue: armLabel, ifFalse: nextLabel });
+                        this.emit({ op: "branch", cond: guardCond, ifTrue: armLabel, ifFalse: nextLabel });
                     }
                     else {
                         this.emit({ op: "branch", cond, ifTrue: armLabel, ifFalse: nextLabel });
                     }
                     this.emit({ op: "label", name: armLabel });
-                    // Bind pattern variables
-                    this.bindPattern(arm.pattern, subject);
+                    // Bind pattern variables (for non-guard case; guard case already bound above)
+                    if (!arm.guard) {
+                        this.bindPattern(arm.pattern, subject);
+                    }
                     const val = this.lowerExpr(arm.body);
                     this.emit({ op: "store", name: resultName, src: val });
                     this.emit({ op: "jump", target: endLabel });
@@ -331,7 +383,12 @@ export class IRGenerator {
                 // Lower lambda to anonymous function
                 const fnName = `__lambda_${this.labelCount++}`;
                 const savedInstrs = this.currentInstrs;
+                const savedScope = this.scopeStack;
                 this.currentInstrs = [];
+                this.scopeStack = [new Map()];
+                for (const p of expr.params) {
+                    this.defineVar(p);
+                }
                 const result = this.lowerExpr(expr.body);
                 this.emit({ op: "ret", value: result });
                 this.functions.push({
@@ -340,6 +397,7 @@ export class IRGenerator {
                     blocks: [{ label: "entry", instrs: this.currentInstrs }],
                 });
                 this.currentInstrs = savedInstrs;
+                this.scopeStack = savedScope;
                 const dest = this.temp();
                 this.emit({ op: "load", dest, name: `@fn:${fnName}` });
                 return dest;
@@ -442,6 +500,7 @@ export class IRGenerator {
                 return dest;
             }
             case "BlockExpr": {
+                this.pushScope();
                 let last = this.temp();
                 this.emit({ op: "const", dest: last, value: null });
                 for (const s of expr.stmts) {
@@ -452,6 +511,7 @@ export class IRGenerator {
                         this.lowerStmt(s);
                     }
                 }
+                this.popScope();
                 return last;
             }
             case "AsyncExpr": {

package/dist/lexer.js

@@ -135,6 +135,10 @@ export function lex(source) {
             const parts = [];
             let hasInterp = false;
             while (i < source.length && peek() !== '"') {
+                if (peek() === "\n") {
+                    // Unterminated string - newline before closing quote
+                    throw new Error(`Unterminated string literal at line ${sl}, col ${sc}`);
+                }
                 if (peek() === "{") {
                     hasInterp = true;
                     if (str.length > 0 || parts.length === 0) {
@@ -145,7 +149,21 @@ export function lex(source) {
                     // Lex the expression inside {} as tokens - just grab until matching }
                     let depth = 1;
                     let interpExpr = "";
+                    const interpLine = line, interpCol = col;
                     while (i < source.length && depth > 0) {
+                        if (peek() === '"') {
+                            // Skip over string literals inside interpolation to avoid miscounting braces
+                            interpExpr += advance(); // opening quote
+                            while (i < source.length && peek() !== '"') {
+                                if (peek() === '\\') {
+                                    interpExpr += advance();
+                                } // escape char
+                                interpExpr += advance();
+                            }
+                            if (i < source.length)
+                                interpExpr += advance(); // closing quote
+                            continue;
+                        }
                         if (peek() === "{")
                             depth++;
                         if (peek() === "}") {
@@ -157,26 +175,84 @@ export function lex(source) {
                     }
                     if (peek() === "}")
                         advance(); // skip }
-                    parts.push(tok(TokenType.Ident, interpExpr, line, col));
+                    // Skip empty interpolation
+                    if (interpExpr.trim().length > 0) {
+                        parts.push(tok(TokenType.Ident, interpExpr, interpLine, interpCol));
+                    }
+                    else {
+                        // Empty interpolation {} - treat as empty string part
+                        parts.push(tok(TokenType.String, "", interpLine, interpCol));
+                    }
                     continue;
                 }
                 if (peek() === "\\") {
                     advance();
+                    if (i >= source.length) {
+                        throw new Error(`Unterminated string literal (escape at end of file) at line ${sl}, col ${sc}`);
+                    }
                     const esc = advance();
                     if (esc === "n")
                         str += "\n";
                     else if (esc === "t")
                         str += "\t";
+                    else if (esc === "r")
+                        str += "\r";
+                    else if (esc === "0")
+                        str += "\0";
                     else if (esc === "\\")
                         str += "\\";
                     else if (esc === '"')
                         str += '"';
+                    else if (esc === "{")
+                        str += "{";
+                    else if (esc === "x") {
+                        // \xNN - hex escape (2 digits)
+                        let hex = "";
+                        for (let h = 0; h < 2 && i < source.length; h++) {
+                            const hc = peek();
+                            if (/[0-9a-fA-F]/.test(hc)) {
+                                hex += advance();
+                            }
+                            else
+                                break;
+                        }
+                        str += hex.length > 0 ? String.fromCharCode(parseInt(hex, 16)) : "x";
+                    }
+                    else if (esc === "u") {
+                        // \u{NNNN} or \uNNNN - unicode escape
+                        if (peek() === "{") {
+                            advance(); // skip {
+                            let hex = "";
+                            while (i < source.length && peek() !== "}") {
+                                hex += advance();
+                            }
+                            if (peek() === "}")
+                                advance();
+                            str += hex.length > 0 ? String.fromCodePoint(parseInt(hex, 16)) : "";
+                        }
+                        else {
+                            // \uNNNN - 4 hex digits
+                            let hex = "";
+                            for (let h = 0; h < 4 && i < source.length; h++) {
+                                const hc = peek();
+                                if (/[0-9a-fA-F]/.test(hc)) {
+                                    hex += advance();
+                                }
+                                else
+                                    break;
+                            }
+                            str += hex.length > 0 ? String.fromCharCode(parseInt(hex, 16)) : "u";
+                        }
+                    }
                     else
                         str += esc;
                     continue;
                 }
                 str += advance();
             }
+            if (i >= source.length) {
+                throw new Error(`Unterminated string literal at line ${sl}, col ${sc}`);
+            }
             if (peek() === '"')
                 advance(); // skip closing quote
             if (hasInterp) {

package/dist/modules.js

@@ -8,8 +8,10 @@ import { createEnv, runStmt } from "./interpreter.js";
 const __filename2 = fileURLToPath(import.meta.url);
 const __dirname2 = dirname(__filename2);
 const moduleCache = new Map();
+const modulesInProgress = new Set();
 export function clearModuleCache() {
     moduleCache.clear();
+    modulesInProgress.clear();
 }
 /**
  * Resolve a module path to a file path.
@@ -44,10 +46,15 @@ export function resolveModule(path, basePath) {
  */
 export function loadModule(filePath) {
     const absPath = resolve(filePath);
+    // Detect circular imports — check before cache since cache is pre-populated with {}
+    if (modulesInProgress.has(absPath)) {
+        throw new Error(`Circular import detected: ${absPath}`);
+    }
     if (moduleCache.has(absPath)) {
         return moduleCache.get(absPath);
     }
-    // Prevent circular imports — set empty first
+    modulesInProgress.add(absPath);
+    // Pre-populate cache to handle any remaining edge cases
     moduleCache.set(absPath, {});
     const source = readFileSync(absPath, "utf-8");
     const tokens = lex(source);
@@ -79,6 +86,7 @@ export function loadModule(filePath) {
         }
     }
     moduleCache.set(absPath, exports);
+    modulesInProgress.delete(absPath);
     return exports;
 }
 /**

package/dist/parser.d.ts

@@ -24,6 +24,7 @@ export declare class Parser {
     private parseDo;
     private parseUse;
     private parseType;
+    private parseRet;
     private parseTypeExpr;
     private parseTypeAtom;
     private parseBlock;
@@ -37,6 +38,7 @@ export declare class Parser {
     private parseIf;
     private parseMatch;
     private parsePattern;
+    private parsePatternAtom;
     private parseToolCall;
 }
 export declare function parse(tokens: Token[]): AST.Program;

package/dist/parser.js

@@ -1,5 +1,5 @@
 // Arc Language Parser - Recursive Descent with Pratt Parsing
-import { TokenType } from "./lexer.js";
+import { TokenType, lex } from "./lexer.js";
 export class ParseError extends Error {
     loc;
     constructor(msg, loc) {
@@ -55,6 +55,7 @@ export class Parser {
             case TokenType.Do: return this.parseDo();
             case TokenType.Use: return this.parseUse();
             case TokenType.Type: return this.parseType();
+            case TokenType.Ret: return this.parseRet();
             default: {
                 const exprLoc = this.loc();
                 const expr = this.parseExpr();
@@ -226,6 +227,16 @@ export class Parser {
         const def = this.parseTypeExpr();
         return { kind: "TypeStmt", name, pub, def, loc };
     }
+    parseRet() {
+        const loc = this.loc();
+        this.expect(TokenType.Ret);
+        let value;
+        // If the next token could start an expression, parse it
+        if (!this.at(TokenType.EOF) && !this.at(TokenType.RBrace) && !this.at(TokenType.Semicolon)) {
+            value = this.parseExpr();
+        }
+        return { kind: "RetStmt", value, loc };
+    }
     parseTypeExpr() {
         let typeExpr = this.parseTypeAtom();
         // Check for enum/union: Type | Type
@@ -405,7 +416,9 @@ export class Parser {
             const op = this.binaryOp();
             if (op) {
                 this.advance();
-                const right = this.parseExpr(prec + 1);
+                // Right-associative for ** (power operator)
+                const nextPrec = op === "**" ? prec : prec + 1;
+                const right = this.parseExpr(nextPrec);
                 left = { kind: "BinaryExpr", op, left, right, loc: left.loc };
                 continue;
             }
@@ -456,7 +469,8 @@ export class Parser {
         // Unary operators
         if (t.type === TokenType.Minus) {
             this.advance();
-            return { kind: "UnaryExpr", op: "-", operand: this.parseExpr(8), loc };
+            // Precedence 7: binds looser than ** so -x ** 2 parses as -(x ** 2)
+            return { kind: "UnaryExpr", op: "-", operand: this.parseExpr(7), loc };
         }
         if (t.type === TokenType.Not) {
             this.advance();
@@ -600,10 +614,13 @@ export class Parser {
                 parts.push(this.advance().value);
             }
             else if (this.at(TokenType.Ident)) {
-                // This is an interpolated expression identifier
+                // The lexer captures the raw text inside {} — re-lex and parse as expression
                 const identToken = this.advance();
-                // Try to parse a more complex expression from the token value
-                parts.push({ kind: "Identifier", name: identToken.value, loc: { line: identToken.line, col: identToken.col } });
+                const exprSource = identToken.value;
+                const exprTokens = lex(exprSource);
+                const exprParser = new Parser(exprTokens);
+                const expr = exprParser.parseExpr();
+                parts.push(expr);
             }
             else {
                 this.advance(); // skip unexpected
@@ -715,12 +732,35 @@ export class Parser {
         return { kind: "MatchExpr", subject, arms, loc };
     }
     parsePattern() {
+        let pattern = this.parsePatternAtom();
+        // Check for or-pattern: pat | pat | ...
+        if (this.at(TokenType.Bar)) {
+            const patterns = [pattern];
+            while (this.at(TokenType.Bar)) {
+                this.advance();
+                patterns.push(this.parsePatternAtom());
+            }
+            return { kind: "OrPattern", patterns, loc: pattern.loc };
+        }
+        return pattern;
+    }
+    parsePatternAtom() {
         const loc = this.loc();
         const t = this.peek();
         if (t.type === TokenType.Ident && t.value === "_") {
             this.advance();
             return { kind: "WildcardPattern", loc };
         }
+        // Negative numeric literals
+        if (t.type === TokenType.Minus) {
+            this.advance();
+            const numTok = this.peek();
+            if (numTok.type === TokenType.Int || numTok.type === TokenType.Float) {
+                this.advance();
+                return { kind: "LiteralPattern", value: -parseFloat(numTok.value), loc };
+            }
+            throw new ParseError(`Expected number after - in pattern`, loc);
+        }
         if (t.type === TokenType.Int || t.type === TokenType.Float) {
             this.advance();
             return { kind: "LiteralPattern", value: parseFloat(t.value), loc };
@@ -741,6 +781,18 @@ export class Parser {
             this.advance();
             return { kind: "LiteralPattern", value: null, loc };
         }
+        // Array pattern: [pat, pat, ...]
+        if (t.type === TokenType.LBracket) {
+            this.advance();
+            const elements = [];
+            while (!this.at(TokenType.RBracket) && !this.at(TokenType.EOF)) {
+                elements.push(this.parsePattern());
+                if (this.at(TokenType.Comma))
+                    this.advance();
+            }
+            this.expect(TokenType.RBracket);
+            return { kind: "ArrayPattern", elements, loc };
+        }
         if (t.type === TokenType.Ident) {
             this.advance();
             return { kind: "BindingPattern", name: t.value, loc };

package/dist/repl.js

@@ -93,12 +93,31 @@ function main() {
         }
         // Multi-line support
         buffer += (buffer ? "\n" : "") + line;
-        // Count braces
-        for (const ch of line) {
-            if (ch === "{")
-                braceDepth++;
-            if (ch === "}")
-                braceDepth--;
+        // Count braces (skip braces inside strings and comments)
+        let inString = false;
+        let escaped = false;
+        for (let ci = 0; ci < line.length; ci++) {
+            const ch = line[ci];
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (ch === "\\") {
+                escaped = true;
+                continue;
+            }
+            if (ch === '"') {
+                inString = !inString;
+                continue;
+            }
+            if (ch === "#" && !inString)
+                break; // rest is comment
+            if (!inString) {
+                if (ch === "{")
+                    braceDepth++;
+                if (ch === "}")
+                    braceDepth--;
+            }
         }
         if (braceDepth > 0) {
             rl.setPrompt("...  ");

package/dist/security.js

@@ -157,7 +157,7 @@ export class SafeInterpreter {
             ctx.tick();
             if (stmt.kind === "UseStmt") {
                 const useStmt = stmt;
-                validateImport(useStmt.module, this.config);
+                validateImport(useStmt.path.join("/"), this.config);
                 if (!this.config.disableImports) {
                     // No file context in sandbox, skip actual import
                 }

package/dist/version.js

@@ -11,14 +11,27 @@ export function printVersion() {
 }
 /** Semver comparison: returns -1, 0, or 1 */
 export function compareSemver(a, b) {
-    const pa = a.split(".").map(Number);
-    const pb = b.split(".").map(Number);
+    // Strip pre-release suffixes for numeric comparison
+    const stripPre = (s) => s.replace(/-.*$/, "");
+    const pa = stripPre(a).split(".").map(Number);
+    const pb = stripPre(b).split(".").map(Number);
     for (let i = 0; i < 3; i++) {
-        if (pa[i] < pb[i])
+        const va = pa[i] ?? 0;
+        const vb = pb[i] ?? 0;
+        if (isNaN(va) || isNaN(vb))
+            continue;
+        if (va < vb)
             return -1;
-        if (pa[i] > pb[i])
+        if (va > vb)
             return 1;
     }
+    // If numeric parts are equal, pre-release < release
+    const aHasPre = a.includes("-");
+    const bHasPre = b.includes("-");
+    if (aHasPre && !bHasPre)
+        return -1;
+    if (!aHasPre && bHasPre)
+        return 1;
     return 0;
 }
 /** Check if a manifest's arc version requirement is compatible */
@@ -32,9 +45,17 @@ export function checkVersionCompatibility(required) {
     }
     if (required.startsWith("^")) {
         const base = required.slice(1);
-        const [major] = base.split(".").map(Number);
-        const [curMajor] = current.split(".").map(Number);
-        const ok = curMajor === major && compareSemver(current, base) >= 0;
+        const parts = base.split(".").map(Number);
+        const curParts = current.split(".").map(Number);
+        let ok;
+        if (parts[0] === 0) {
+            // ^0.x.y means >=0.x.y, <0.(x+1).0 — constrain on minor when major is 0
+            ok = curParts[0] === 0 && curParts[1] === parts[1] && compareSemver(current, base) >= 0;
+        }
+        else {
+            // ^x.y.z means >=x.y.z, <(x+1).0.0
+            ok = curParts[0] === parts[0] && compareSemver(current, base) >= 0;
+        }
         return { compatible: ok, message: ok ? "Compatible" : `Requires Arc ${required}, current is ${current}` };
     }
     if (required.startsWith("~")) {
@@ -45,7 +66,7 @@ export function checkVersionCompatibility(required) {
         return { compatible: ok, message: ok ? "Compatible" : `Requires Arc ${required}, current is ${current}` };
     }
     // Exact match
-    const ok = compareSemver(current, required) >= 0;
+    const ok = compareSemver(current, required) === 0;
     return { compatible: ok, message: ok ? "Compatible" : `Requires Arc ${required}, current is ${current}` };
 }
 const deprecations = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arc-lang",
-  "version": "0.5.2",
+  "version": "0.5.4",
   "description": "Arc ⚡ — A programming language designed by AI agents, for AI agents. 27-63% fewer tokens than JavaScript.",
   "type": "module",
   "bin": {