arc-lang 0.5.0

package/dist/codegen-js.js

@@ -0,0 +1,168 @@
+// Arc IR → JavaScript Code Generator
+export function generateJS(module) {
+    const lines = [];
+    lines.push("// Generated by Arc Compiler");
+    lines.push("");
+    // Runtime helpers
+    lines.push(`// Arc Runtime`);
+    lines.push(`const __arc_runtime = {`);
+    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(`  head(a) { return a[0]; },`);
+    lines.push(`  tail(a) { return a.slice(1); },`);
+    lines.push(`  map(a, f) { return a.map(f); },`);
+    lines.push(`  filter(a, f) { return a.filter(f); },`);
+    lines.push(`  fold(a, init, f) { return a.reduce((acc, x) => f(acc, x), init); },`);
+    lines.push(`  range(start, end) { const r = []; for (let i = start; i < end; i++) r.push(i); return r; },`);
+    lines.push(`  keys(m) { return m && m.__map ? Array.from(m.entries.keys()) : Object.keys(m || {}); },`);
+    lines.push(`  values(m) { return m && m.__map ? Array.from(m.entries.values()) : Object.values(m || {}); },`);
+    lines.push(`  type(v) { if (v === null) return "nil"; if (Array.isArray(v)) return "list"; return typeof v; },`);
+    lines.push(`  abs(n) { return Math.abs(n); },`);
+    lines.push(`  max(a, b) { return Math.max(a, b); },`);
+    lines.push(`  min(a, b) { return Math.min(a, b); },`);
+    lines.push(`  floor(n) { return Math.floor(n); },`);
+    lines.push(`  ceil(n) { return Math.ceil(n); },`);
+    lines.push(`  round(n) { return Math.round(n); },`);
+    lines.push(`  sort(a) { return [...a].sort((x,y) => x < y ? -1 : x > y ? 1 : 0); },`);
+    lines.push(`  reverse(a) { return [...a].reverse(); },`);
+    lines.push(`  contains(a, v) { return Array.isArray(a) ? a.includes(v) : typeof a === "string" ? a.includes(v) : false; },`);
+    lines.push(`  join(a, sep) { return a.join(sep); },`);
+    lines.push(`  split(s, sep) { return s.split(sep); },`);
+    lines.push(`  trim(s) { return s.trim(); },`);
+    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(`  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]]); },`);
+    lines.push(`  enumerate(a) { return a.map((x, i) => [i, x]); },`);
+    lines.push(`  slice(a, s, e) { return a.slice(s, e); },`);
+    lines.push(`  append(a, v) { return [...a, v]; },`);
+    lines.push(`  concat(a, b) { return [...a, ...b]; },`);
+    lines.push(`  unique(a) { return [...new Set(a)]; },`);
+    lines.push(`  int(v) { return parseInt(v, 10); },`);
+    lines.push(`  float(v) { return parseFloat(v); },`);
+    lines.push(`  __await(v) { return v && v.__async ? v.thunk() : v; },`);
+    lines.push(`  __fetch_parallel(...targets) { return targets; },`);
+    lines.push(`  __make_map(keys, values) { const m = { __map: true, entries: new Map() }; for (let i = 0; i < keys.length; i++) m.entries.set(keys[i], values[i]); return m; },`);
+    lines.push(`};`);
+    lines.push("");
+    // Emit main with hoisted functions
+    lines.push("// Main");
+    lines.push("(function() {");
+    // Hoist function definitions inside the scope
+    for (const fn of module.functions) {
+        lines.push(emitFunction(fn, "  "));
+        lines.push("");
+    }
+    for (const block of module.main) {
+        lines.push(...emitBlock(block, "  "));
+    }
+    lines.push("})();");
+    return lines.join("\n");
+}
+function emitFunction(fn, baseIndent = "") {
+    const lines = [];
+    lines.push(`${baseIndent}function ${S(fn.name)}(${fn.params.map(S).join(", ")}) {`);
+    for (const block of fn.blocks) {
+        lines.push(...emitBlock(block, baseIndent + "  "));
+    }
+    lines.push(`${baseIndent}}`);
+    return lines.join("\n");
+}
+function emitBlock(block, indent) {
+    const lines = [];
+    for (const instr of block.instrs) {
+        lines.push(indent + emitInstr(instr));
+    }
+    return lines;
+}
+function emitInstr(instr) {
+    switch (instr.op) {
+        case "const":
+            return `var ${S(instr.dest)} = ${JSON.stringify(instr.value)};`;
+        case "load":
+            if (instr.name.startsWith("@fn:")) {
+                return `var ${S(instr.dest)} = ${S(instr.name.slice(4))};`;
+            }
+            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))};`;
+            }
+            return `var ${S(instr.name)} = ${S(instr.src)};`;
+        case "binop":
+            return `var ${S(instr.dest)} = ${emitBinop(instr.operator, S(instr.left), S(instr.right))};`;
+        case "unop":
+            return `var ${S(instr.dest)} = ${emitUnop(instr.operator, S(instr.operand))};`;
+        case "call":
+            return `var ${S(instr.dest)} = ${emitCall(instr.fn, instr.args.map(S))};`;
+        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)}];`;
+        case "index":
+            return `var ${S(instr.dest)} = ${S(instr.obj)}[${S(instr.idx)}];`;
+        case "setfield":
+            return `if (${S(instr.obj)} && ${S(instr.obj)}.__map) { ${S(instr.obj)}.entries.set(${JSON.stringify(instr.prop)}, ${S(instr.src)}); } else { ${S(instr.obj)}[${JSON.stringify(instr.prop)}] = ${S(instr.src)}; }`;
+        case "setindex":
+            return `${S(instr.obj)}[${S(instr.idx)}] = ${S(instr.src)};`;
+        case "jump":
+            return `/* jump ${instr.target} */`;
+        case "branch":
+            return `if (${S(instr.cond)}) { /* ${instr.ifTrue} */ } /* branch */`;
+        case "phi":
+            return `var ${S(instr.dest)} = undefined; /* phi */`;
+        case "ret":
+            return instr.value ? `return ${S(instr.value)};` : "return;";
+        case "list":
+            return `var ${S(instr.dest)} = [${instr.elements.map(S).join(", ")}];`;
+        case "map":
+            return `var ${S(instr.dest)} = __arc_runtime.__make_map([${instr.keys.map(S).join(", ")}], [${instr.values.map(S).join(", ")}]);`;
+        case "label":
+            return `/* ${instr.name}: */`;
+        case "print":
+            return `__arc_runtime.print(${S(instr.value)});`;
+        case "range":
+            return `var ${S(instr.dest)} = __arc_runtime.range(${S(instr.start)}, ${S(instr.end)});`;
+        case "nop":
+            return "/* nop */";
+    }
+}
+function emitBinop(op, left, right) {
+    switch (op) {
+        case "++": return `String(${left}) + String(${right})`;
+        case "and": return `(${left} && ${right})`;
+        case "or": return `(${left} || ${right})`;
+        case "==": return `(${left} === ${right})`;
+        case "!=": return `(${left} !== ${right})`;
+        case "**": return `(${left} ** ${right})`;
+        case "%": return `(${left} % ${right})`;
+        default: return `(${left} ${op} ${right})`;
+    }
+}
+function emitUnop(op, operand) {
+    switch (op) {
+        case "not": return `(!${operand})`;
+        default: return `(${op}${operand})`;
+    }
+}
+function emitCall(fn, args) {
+    const builtins = [
+        "len", "str", "push", "print", "head", "tail", "map", "filter", "fold",
+        "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"
+    ];
+    if (builtins.includes(fn)) {
+        return `__arc_runtime.${fn}(${args.join(", ")})`;
+    }
+    return `${S(fn)}(${args.join(", ")})`;
+}
+function sanitizeName(name) {
+    return name.replace(/[^a-zA-Z0-9_$]/g, "_");
+}
+function S(name) { return sanitizeName(name); }

package/dist/codegen.d.ts

@@ -0,0 +1,2 @@
+import { IRModule } from "./ir.js";
+export declare function generateWAT(module: IRModule): string;

package/dist/codegen.js

@@ -0,0 +1,364 @@
+// Arc IR → WAT (WebAssembly Text Format) Code Generator
+export function generateWAT(module) {
+    const gen = new WATGenerator();
+    return gen.generate(module);
+}
+class WATGenerator {
+    locals = new Set();
+    stringTable = new Map();
+    stringOffset = 0;
+    dataSegments = [];
+    generate(module) {
+        const lines = [];
+        // First pass: collect all strings and locals
+        this.collectStrings(module);
+        lines.push("(module");
+        // Import runtime functions
+        lines.push('  ;; Runtime imports');
+        lines.push('  (import "arc" "print_i32" (func $print_i32 (param i32)))');
+        lines.push('  (import "arc" "print_f64" (func $print_f64 (param f64)))');
+        lines.push('  (import "arc" "print_str" (func $print_str (param i32 i32)))');
+        lines.push('  (import "arc" "tool_call" (func $tool_call (param i32 i32 i32 i32) (result i32)))');
+        lines.push('  (import "arc" "alloc" (func $alloc (param i32) (result i32)))');
+        lines.push('  (import "arc" "list_new" (func $list_new (result i32)))');
+        lines.push('  (import "arc" "list_push" (func $list_push (param i32 i32) (result i32)))');
+        lines.push('  (import "arc" "list_get" (func $list_get (param i32 i32) (result i32)))');
+        lines.push('  (import "arc" "list_len" (func $list_len (param i32) (result i32)))');
+        lines.push('  (import "arc" "map_new" (func $map_new (result i32)))');
+        lines.push('  (import "arc" "map_set" (func $map_set (param i32 i32 i32) (result i32)))');
+        lines.push('  (import "arc" "map_get" (func $map_get (param i32 i32) (result i32)))');
+        lines.push("");
+        // Memory
+        lines.push("  (memory (export \"memory\") 1)");
+        lines.push("");
+        // Data segments for strings
+        if (this.dataSegments.length > 0) {
+            lines.push("  ;; String data");
+            for (const seg of this.dataSegments) {
+                lines.push(`  ${seg}`);
+            }
+            lines.push("");
+        }
+        // Global variables for locals (simple approach: use globals for main scope)
+        lines.push("  ;; Globals");
+        lines.push(`  (global $__sp (mut i32) (i32.const ${this.stringOffset}))`);
+        lines.push("");
+        // Emit functions
+        for (const fn of module.functions) {
+            lines.push(this.emitFunction(fn));
+            lines.push("");
+        }
+        // Emit main as _start
+        lines.push('  (func (export "_start")');
+        this.locals.clear();
+        // Collect locals from main blocks
+        for (const block of module.main) {
+            this.collectLocals(block);
+        }
+        for (const local of this.locals) {
+            lines.push(`    (local $${sanitize(local)} i32)`);
+        }
+        for (const block of module.main) {
+            lines.push(...this.emitBlockInstrs(block, "    "));
+        }
+        lines.push("  )");
+        lines.push(")");
+        return lines.join("\n");
+    }
+    collectStrings(module) {
+        const visit = (instrs) => {
+            for (const instr of instrs) {
+                if (instr.op === "const" && typeof instr.value === "string") {
+                    this.addString(instr.value);
+                }
+            }
+        };
+        for (const fn of module.functions) {
+            for (const block of fn.blocks)
+                visit(block.instrs);
+        }
+        for (const block of module.main)
+            visit(block.instrs);
+    }
+    addString(s) {
+        if (this.stringTable.has(s))
+            return this.stringTable.get(s);
+        const offset = this.stringOffset;
+        const encoded = new TextEncoder().encode(s);
+        this.stringTable.set(s, offset);
+        // Escape for WAT data segment
+        let escaped = "";
+        for (const b of encoded) {
+            escaped += "\\" + b.toString(16).padStart(2, "0");
+        }
+        this.dataSegments.push(`(data (i32.const ${offset}) "${escaped}")`);
+        this.stringOffset += encoded.length;
+        return offset;
+    }
+    collectLocals(block) {
+        for (const instr of block.instrs) {
+            if ("dest" in instr && instr.dest)
+                this.locals.add(instr.dest);
+            if (instr.op === "store")
+                this.locals.add(instr.name);
+        }
+    }
+    emitFunction(fn) {
+        const lines = [];
+        this.locals.clear();
+        // Collect locals
+        for (const block of fn.blocks)
+            this.collectLocals(block);
+        const params = fn.params.map(p => `(param $${sanitize(p)} i32)`).join(" ");
+        lines.push(`  (func $${sanitize(fn.name)} ${params} (result i32)`);
+        // Declare locals (excluding params)
+        const paramSet = new Set(fn.params);
+        for (const local of this.locals) {
+            if (!paramSet.has(local)) {
+                lines.push(`    (local $${sanitize(local)} i32)`);
+            }
+        }
+        for (const block of fn.blocks) {
+            lines.push(...this.emitBlockInstrs(block, "    "));
+        }
+        // Default return
+        lines.push("    i32.const 0");
+        lines.push("  )");
+        return lines.join("\n");
+    }
+    emitBlockInstrs(block, indent) {
+        const lines = [];
+        lines.push(`${indent};; ${block.label}:`);
+        for (const instr of block.instrs) {
+            lines.push(...this.emitInstr(instr, indent));
+        }
+        return lines;
+    }
+    emitInstr(instr, indent) {
+        const lines = [];
+        const I = indent;
+        switch (instr.op) {
+            case "const": {
+                if (typeof instr.value === "number") {
+                    if (Number.isInteger(instr.value)) {
+                        lines.push(`${I}i32.const ${instr.value}`);
+                    }
+                    else {
+                        // Store float as i32 bits (simplified — real impl would use f64)
+                        lines.push(`${I}i32.const ${Math.round(instr.value)}`);
+                    }
+                }
+                else if (typeof instr.value === "boolean") {
+                    lines.push(`${I}i32.const ${instr.value ? 1 : 0}`);
+                }
+                else if (instr.value === null) {
+                    lines.push(`${I}i32.const 0`);
+                }
+                else if (typeof instr.value === "string") {
+                    const offset = this.stringTable.get(instr.value) ?? 0;
+                    const len = new TextEncoder().encode(instr.value).length;
+                    // Pack offset and length — simplified: just store offset
+                    lines.push(`${I}i32.const ${offset} ;; str "${instr.value.slice(0, 20)}"`);
+                }
+                lines.push(`${I}local.set $${sanitize(instr.dest)}`);
+                break;
+            }
+            case "load": {
+                if (instr.name.startsWith("@fn:")) {
+                    lines.push(`${I}i32.const 0 ;; fn ref ${instr.name}`);
+                }
+                else {
+                    lines.push(`${I}local.get $${sanitize(instr.name)}`);
+                }
+                lines.push(`${I}local.set $${sanitize(instr.dest)}`);
+                break;
+            }
+            case "store": {
+                if (instr.src.startsWith("@fn:")) {
+                    lines.push(`${I}i32.const 0 ;; fn ref ${instr.src}`);
+                }
+                else {
+                    lines.push(`${I}local.get $${sanitize(instr.src)}`);
+                }
+                lines.push(`${I}local.set $${sanitize(instr.name)}`);
+                break;
+            }
+            case "binop": {
+                lines.push(`${I}local.get $${sanitize(instr.left)}`);
+                lines.push(`${I}local.get $${sanitize(instr.right)}`);
+                lines.push(`${I}${watBinop(instr.operator)}`);
+                lines.push(`${I}local.set $${sanitize(instr.dest)}`);
+                break;
+            }
+            case "unop": {
+                if (instr.operator === "not" || instr.operator === "!") {
+                    lines.push(`${I}local.get $${sanitize(instr.operand)}`);
+                    lines.push(`${I}i32.eqz`);
+                }
+                else if (instr.operator === "-") {
+                    lines.push(`${I}i32.const 0`);
+                    lines.push(`${I}local.get $${sanitize(instr.operand)}`);
+                    lines.push(`${I}i32.sub`);
+                }
+                else {
+                    lines.push(`${I}local.get $${sanitize(instr.operand)}`);
+                }
+                lines.push(`${I}local.set $${sanitize(instr.dest)}`);
+                break;
+            }
+            case "call": {
+                // Push args
+                for (const arg of instr.args) {
+                    lines.push(`${I}local.get $${sanitize(arg)}`);
+                }
+                // Call
+                if (isRuntimeBuiltin(instr.fn)) {
+                    lines.push(`${I}call $__rt_${sanitize(instr.fn)}`);
+                }
+                else {
+                    lines.push(`${I}call $${sanitize(instr.fn)}`);
+                }
+                lines.push(`${I}local.set $${sanitize(instr.dest)}`);
+                break;
+            }
+            case "toolcall": {
+                lines.push(`${I}local.get $${sanitize(instr.url)}`);
+                lines.push(`${I}i32.const ${this.stringTable.get(instr.method) ?? this.addString(instr.method)}`);
+                lines.push(`${I}i32.const ${instr.method.length}`);
+                if (instr.body) {
+                    lines.push(`${I}local.get $${sanitize(instr.body)}`);
+                }
+                else {
+                    lines.push(`${I}i32.const 0`);
+                }
+                lines.push(`${I}call $tool_call`);
+                lines.push(`${I}local.set $${sanitize(instr.dest)}`);
+                break;
+            }
+            case "field": {
+                lines.push(`${I}local.get $${sanitize(instr.obj)}`);
+                const propOffset = this.stringTable.get(instr.prop) ?? this.addString(instr.prop);
+                lines.push(`${I}i32.const ${propOffset}`);
+                lines.push(`${I}call $map_get`);
+                lines.push(`${I}local.set $${sanitize(instr.dest)}`);
+                break;
+            }
+            case "index": {
+                lines.push(`${I}local.get $${sanitize(instr.obj)}`);
+                lines.push(`${I}local.get $${sanitize(instr.idx)}`);
+                lines.push(`${I}call $list_get`);
+                lines.push(`${I}local.set $${sanitize(instr.dest)}`);
+                break;
+            }
+            case "setfield": {
+                lines.push(`${I}local.get $${sanitize(instr.obj)}`);
+                const pOff = this.stringTable.get(instr.prop) ?? this.addString(instr.prop);
+                lines.push(`${I}i32.const ${pOff}`);
+                lines.push(`${I}local.get $${sanitize(instr.src)}`);
+                lines.push(`${I}call $map_set`);
+                lines.push(`${I}drop`);
+                break;
+            }
+            case "setindex": {
+                lines.push(`${I};; setindex ${instr.obj}[${instr.idx}] = ${instr.src}`);
+                break;
+            }
+            case "list": {
+                lines.push(`${I}call $list_new`);
+                lines.push(`${I}local.set $${sanitize(instr.dest)}`);
+                for (const elem of instr.elements) {
+                    lines.push(`${I}local.get $${sanitize(instr.dest)}`);
+                    lines.push(`${I}local.get $${sanitize(elem)}`);
+                    lines.push(`${I}call $list_push`);
+                    lines.push(`${I}local.set $${sanitize(instr.dest)}`);
+                }
+                break;
+            }
+            case "map": {
+                lines.push(`${I}call $map_new`);
+                lines.push(`${I}local.set $${sanitize(instr.dest)}`);
+                for (let i = 0; i < instr.keys.length; i++) {
+                    lines.push(`${I}local.get $${sanitize(instr.dest)}`);
+                    lines.push(`${I}local.get $${sanitize(instr.keys[i])}`);
+                    lines.push(`${I}local.get $${sanitize(instr.values[i])}`);
+                    lines.push(`${I}call $map_set`);
+                    lines.push(`${I}local.set $${sanitize(instr.dest)}`);
+                }
+                break;
+            }
+            case "jump": {
+                lines.push(`${I};; jump ${instr.target}`);
+                break;
+            }
+            case "branch": {
+                lines.push(`${I}local.get $${sanitize(instr.cond)}`);
+                lines.push(`${I};; branch -> ${instr.ifTrue} / ${instr.ifFalse}`);
+                break;
+            }
+            case "label": {
+                lines.push(`${I};; label ${instr.name}:`);
+                break;
+            }
+            case "print": {
+                lines.push(`${I}local.get $${sanitize(instr.value)}`);
+                lines.push(`${I}call $print_i32`);
+                break;
+            }
+            case "range": {
+                lines.push(`${I};; range(${instr.start}, ${instr.end})`);
+                lines.push(`${I}call $list_new`);
+                lines.push(`${I}local.set $${sanitize(instr.dest)}`);
+                break;
+            }
+            case "ret": {
+                if (instr.value) {
+                    lines.push(`${I}local.get $${sanitize(instr.value)}`);
+                    lines.push(`${I}return`);
+                }
+                else {
+                    lines.push(`${I}i32.const 0`);
+                    lines.push(`${I}return`);
+                }
+                break;
+            }
+            case "phi": {
+                lines.push(`${I};; phi ${instr.dest}`);
+                lines.push(`${I}i32.const 0`);
+                lines.push(`${I}local.set $${sanitize(instr.dest)}`);
+                break;
+            }
+            case "nop": {
+                lines.push(`${I}nop`);
+                break;
+            }
+        }
+        return lines;
+    }
+}
+function watBinop(op) {
+    switch (op) {
+        case "+": return "i32.add";
+        case "-": return "i32.sub";
+        case "*": return "i32.mul";
+        case "/": return "i32.div_s";
+        case "%": return "i32.rem_s";
+        case "==": return "i32.eq";
+        case "!=": return "i32.ne";
+        case "<": return "i32.lt_s";
+        case ">": return "i32.gt_s";
+        case "<=": return "i32.le_s";
+        case ">=": return "i32.ge_s";
+        case "and": return "i32.and";
+        case "or": return "i32.or";
+        case "**": return "i32.mul ;; TODO: power";
+        case "++": return "i32.add ;; TODO: string concat";
+        default: return `i32.add ;; TODO: ${op}`;
+    }
+}
+function isRuntimeBuiltin(fn) {
+    return ["len", "str", "push", "print", "head", "tail", "map", "filter", "fold",
+        "range", "keys", "values", "type", "__await", "__fetch_parallel"].includes(fn);
+}
+function sanitize(name) {
+    return name.replace(/[^a-zA-Z0-9_]/g, "_");
+}

package/dist/errors.d.ts

@@ -0,0 +1,52 @@
+import * as AST from "./ast.js";
+export declare enum ErrorCode {
+    UNEXPECTED_TOKEN = "ARC001",
+    MISSING_CLOSING_PAREN = "ARC002",
+    MISSING_CLOSING_BRACKET = "ARC003",
+    MISSING_CLOSING_BRACE = "ARC004",
+    EXPECTED_EXPRESSION = "ARC005",
+    INVALID_ASSIGNMENT = "ARC006",
+    UNTERMINATED_STRING = "ARC007",
+    INVALID_NUMBER = "ARC008",
+    TYPE_MISMATCH = "ARC100",
+    INVALID_OPERATOR = "ARC101",
+    NOT_CALLABLE = "ARC102",
+    WRONG_ARITY = "ARC103",
+    UNDEFINED_VARIABLE = "ARC200",
+    IMMUTABLE_REASSIGN = "ARC201",
+    INDEX_OUT_OF_BOUNDS = "ARC202",
+    DIVISION_BY_ZERO = "ARC203",
+    NOT_ITERABLE = "ARC204",
+    ASSERTION_FAILED = "ARC205",
+    PROPERTY_ACCESS = "ARC206",
+    MODULE_NOT_FOUND = "ARC300",
+    CIRCULAR_IMPORT = "ARC301",
+    SOURCE_TOO_LARGE = "ARC400",
+    NESTING_TOO_DEEP = "ARC401",
+    EXECUTION_LIMIT = "ARC402",
+    RECURSION_LIMIT = "ARC403",
+    TOOL_CALL_BLOCKED = "ARC404",
+    IMPORT_BLOCKED = "ARC405",
+    TIMEOUT = "ARC406"
+}
+export type ErrorCategory = "ParseError" | "TypeError" | "RuntimeError" | "ImportError" | "SecurityError";
+export interface ArcError {
+    code: ErrorCode;
+    category: ErrorCategory;
+    message: string;
+    loc?: AST.Loc;
+    source?: string;
+    suggestion?: string;
+}
+export declare function levenshtein(a: string, b: string): number;
+export declare function findClosestMatch(name: string, candidates: string[], maxDistance?: number): string | null;
+export declare function formatError(error: ArcError, useColor?: boolean): string;
+export declare function undefinedVariableError(name: string, candidates: string[], loc?: AST.Loc, source?: string): ArcError;
+export declare function parseError(message: string, loc?: AST.Loc, source?: string, suggestion?: string): ArcError;
+export declare function typeError(message: string, loc?: AST.Loc, source?: string): ArcError;
+export declare function runtimeError(code: ErrorCode, message: string, loc?: AST.Loc, source?: string, suggestion?: string): ArcError;
+export declare function importError(message: string, loc?: AST.Loc, source?: string): ArcError;
+export declare function securityError(code: ErrorCode, message: string): ArcError;
+export declare function prettyPrintError(err: Error, source?: string, useColor?: boolean): string;
+export declare function setPrettyErrors(enabled: boolean): void;
+export declare function isPrettyErrorsEnabled(): boolean;