arc-lang 0.6.1 → 0.6.2

package/dist/interpreter.js

@@ -202,12 +202,12 @@ function makePrelude(env) {
         reduce: (list, fn, init) => {
             if (!Array.isArray(list))
                 throw new Error("reduce expects a list");
-            let acc = init ?? list[0];
+            let acc = init !== undefined ? init : list[0];
             const start = init !== undefined ? 0 : 1;
             for (let i = start; i < list.length; i++) {
                 acc = callFn(fn, [acc, list[i]]);
             }
-            return acc;
+            return acc === undefined ? null : acc;
         },
         fold: (list, init, fn) => {
             if (!Array.isArray(list))
@@ -249,7 +249,7 @@ function makePrelude(env) {
                 return 0;
             return list.reduce((a, b) => a + (typeof b === "number" ? b : 0), 0);
         },
-        flat: (list) => Array.isArray(list) ? list.flat() : list,
+        flat: (list) => Array.isArray(list) ? list.flat(Infinity) : list,
         zip: (a, b) => {
             if (!Array.isArray(a) || !Array.isArray(b))
                 return [];
@@ -262,7 +262,7 @@ function makePrelude(env) {
             return list.map((v, i) => [i, v]);
         },
         trim: (s) => typeof s === "string" ? s.trim() : s,
-        split: (s, sep) => typeof s === "string" ? s.split(sep) : [],
+        split: (s, sep) => typeof s === "string" ? (sep === "" ? [...s] : s.split(sep)) : [],
         join: (list, sep) => Array.isArray(list) ? list.map(toStr).join(sep) : "",
         upper: (s) => typeof s === "string" ? s.toUpperCase() : s,
         lower: (s) => typeof s === "string" ? s.toLowerCase() : s,
@@ -329,7 +329,7 @@ function makePrelude(env) {
                 return [...a, ...b];
             return toStr(a) + toStr(b);
         },
-        chars: (s) => typeof s === "string" ? s.split("") : [],
+        chars: (s) => typeof s === "string" ? [...s] : [],
         repeat: (s, n) => typeof s === "string" ? s.repeat(n) : s,
         slice: (v, start, end) => {
             const endVal = (end === null || end === undefined) ? undefined : end;
@@ -360,10 +360,13 @@ function makePrelude(env) {
             return nodeCrypto.createHash(algorithm).update(data == null ? "" : data).digest("hex");
         },
         crypto_hmac: (algorithm, key, data) => {
-            return nodeCrypto.createHmac(algorithm, key).update(data).digest("hex");
+            return nodeCrypto.createHmac(algorithm, key == null ? "" : key).update(data == null ? "" : data).digest("hex");
         },
         crypto_random_bytes: (n) => {
-            const buf = nodeCrypto.randomBytes(n);
+            const count = n;
+            if (count <= 0)
+                return [];
+            const buf = nodeCrypto.randomBytes(count);
             return Array.from(buf);
         },
         crypto_random_int: (min, max) => {
@@ -373,7 +376,7 @@ function makePrelude(env) {
         },
         crypto_uuid: () => nodeCrypto.randomUUID(),
         crypto_encode_base64: (s) => Buffer.from(s == null ? "" : s).toString("base64"),
-        crypto_decode_base64: (s) => Buffer.from(s, "base64").toString("utf-8"),
+        crypto_decode_base64: (s) => s == null ? "" : Buffer.from(s, "base64").toString("utf-8"),
         // --- net natives ---
         net_url_parse: (url) => {
             try {
@@ -404,7 +407,20 @@ function makePrelude(env) {
             const str = s.startsWith("?") ? s.slice(1) : s;
             const params = new URLSearchParams(str);
             const m = new Map();
-            params.forEach((v, k) => m.set(k, v));
+            params.forEach((v, k) => {
+                const existing = m.get(k);
+                if (existing !== undefined) {
+                    if (Array.isArray(existing)) {
+                        existing.push(v);
+                    }
+                    else {
+                        m.set(k, [existing, v]);
+                    }
+                }
+                else {
+                    m.set(k, v);
+                }
+            });
             return { __map: true, entries: m };
         },
         net_query_stringify: (map) => {
@@ -423,7 +439,7 @@ function makePrelude(env) {
             // IPv4
             const v4 = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(str);
             if (v4)
-                return v4.slice(1).every(n => parseInt(n) <= 255);
+                return v4.slice(1).every(n => parseInt(n) <= 255 && (n === "0" || !n.startsWith("0")));
             // IPv6 (simplified check)
             if (str.includes(":")) {
                 try {
@@ -469,41 +485,41 @@ function makePrelude(env) {
                     const errMap = new Map();
                     errMap.set("ok", false);
                     errMap.set("error", "argument is not a function");
-                    return { __map: true, entries: errMap };
+                    return { __map: true, __result: true, entries: errMap };
                 }
                 const result = typeof fn === "function" ? fn() : callFn(fn, []);
                 const okMap = new Map();
                 okMap.set("ok", true);
                 okMap.set("value", result);
-                return { __map: true, entries: okMap };
+                return { __map: true, __result: true, entries: okMap };
             }
             catch (e) {
                 const errMap = new Map();
                 errMap.set("ok", false);
                 errMap.set("error", e.message ?? toStr(e));
-                return { __map: true, entries: errMap };
+                return { __map: true, __result: true, entries: errMap };
             }
         },
         Ok: (v) => {
             const m = new Map();
             m.set("ok", true);
             m.set("value", v);
-            return { __map: true, entries: m };
+            return { __map: true, __result: true, entries: m };
         },
         Err: (e) => {
             const m = new Map();
             m.set("ok", false);
             m.set("error", e);
-            return { __map: true, entries: m };
+            return { __map: true, __result: true, entries: m };
         },
         is_ok: (v) => {
-            if (v && typeof v === "object" && "__map" in v) {
+            if (v && typeof v === "object" && "__map" in v && "__result" in v) {
                 return v.entries.get("ok") === true;
             }
             return false;
         },
         is_err: (v) => {
-            if (v && typeof v === "object" && "__map" in v) {
+            if (v && typeof v === "object" && "__map" in v && "__result" in v) {
                 return v.entries.get("ok") === false;
             }
             return false;
@@ -534,7 +550,7 @@ function makePrelude(env) {
                     const newMap = new Map();
                     newMap.set("ok", true);
                     newMap.set("value", result);
-                    return { __map: true, entries: newMap };
+                    return { __map: true, __result: true, entries: newMap };
                 }
                 return v; // pass Err through
             }
@@ -566,7 +582,12 @@ function makePrelude(env) {
         },
         regex_try_new: (pattern) => {
             try {
-                new RegExp(pattern);
+                const p = pattern;
+                // ReDoS protection: same check as regex_new
+                if (/(\+|\*|\{)\s*(\+|\*|\{)/.test(p) || /\([^)]*(\+|\*)\)[+*]/.test(p)) {
+                    return null;
+                }
+                new RegExp(p);
                 const m = new Map();
                 m.set("pattern", pattern);
                 m.set("__regex", true);
@@ -721,8 +742,14 @@ function makePrelude(env) {
                     si++;
                 }
             }
-            const result = new Date(year, month - 1, day, hour, min, sec).getTime();
-            return isNaN(result) ? null : result;
+            const d = new Date(year, month - 1, day, hour, min, sec);
+            const result = d.getTime();
+            if (isNaN(result))
+                return null;
+            // Validate that JS didn't roll over an invalid date (e.g. Feb 30 → Mar 2)
+            if (d.getFullYear() !== year || d.getMonth() !== month - 1 || d.getDate() !== day)
+                return null;
+            return result;
         },
         __builtin_date_format: (ts, fmt) => {
             const d = new Date(ts);
@@ -881,11 +908,14 @@ function makePrelude(env) {
                         if (dangerous.test(cmd)) {
                             throw new Error(`Potentially unsafe command (injection risk): ${cmd}`);
                         }
-                        return execSync(cmd, { encoding: "utf-8", timeout: 10000 }).trim();
+                        return execSync(cmd, { encoding: "utf-8", timeout: 10000, stdio: ["pipe", "pipe", "pipe"] }).trim();
                     }
                     catch (e) {
                         if (e.message?.includes("injection risk"))
                             throw e;
+                        // Return stderr if available
+                        if (e.stderr)
+                            return e.stderr.toString().trim();
                         return null;
                     }
                 }
@@ -905,15 +935,16 @@ function makePrelude(env) {
                 // --- prompt natives ---
                 case "prompt.token_count": {
                     const text = String(args[0] ?? "");
-                    return Math.ceil(text.length / 4);
+                    return Math.ceil([...text].length / 4);
                 }
                 case "prompt.token_truncate": {
                     const text = String(args[0] ?? "");
                     const maxTokens = args[1];
+                    const codepoints = [...text];
                     const maxChars = maxTokens * 4;
-                    if (text.length <= maxChars)
+                    if (codepoints.length <= maxChars)
                         return text;
-                    return text.slice(0, maxChars);
+                    return codepoints.slice(0, maxChars).join("");
                 }
                 case "prompt.chunk": {
                     const text = String(args[0] ?? "");
@@ -921,9 +952,10 @@ function makePrelude(env) {
                     if (maxTokens <= 0)
                         return [];
                     const chunkSize = maxTokens * 4;
+                    const codepoints = [...text];
                     const chunks = [];
-                    for (let i = 0; i < text.length; i += chunkSize) {
-                        chunks.push(text.slice(i, i + chunkSize));
+                    for (let i = 0; i < codepoints.length; i += chunkSize) {
+                        chunks.push(codepoints.slice(i, i + chunkSize).join(""));
                     }
                     return chunks.length > 0 ? chunks : [""];
                 }
@@ -999,7 +1031,12 @@ function makePrelude(env) {
                 }
                 case "store.entries": {
                     const s = args[0];
-                    return Object.entries(s.data).map(([k, v]) => ({ key: k, value: v }));
+                    return Object.entries(s.data).map(([k, v]) => {
+                        const m = new Map();
+                        m.set("key", k);
+                        m.set("value", v);
+                        return { __map: true, entries: m };
+                    });
                 }
                 case "store.clear": {
                     const s = args[0];
@@ -1044,6 +1081,10 @@ function makePrelude(env) {
                 case "math.cbrt": return Math.cbrt(args[0]);
                 case "math.pow": return Math.pow(args[0], args[1]);
                 case "math.ceil": return Math.ceil(args[0]);
+                case "json.from_codepoint": {
+                    const hex = args[0];
+                    return String.fromCodePoint(parseInt(hex, 16));
+                }
                 case "csv.parse": {
                     const text = args[0].trim();
                     if (text === "")
@@ -1079,7 +1120,7 @@ function makePrelude(env) {
                                     i++;
                                 }
                             }
-                            row.push(value.trim());
+                            row.push(value);
                             if (i < text.length && text[i] === ',') {
                                 i++;
                             }
@@ -1203,10 +1244,37 @@ function makePrelude(env) {
                                     }
                                     else {
                                         children = parseHTML(html.slice(i));
+                                        // Bug #13: use depth counter to find correct closing tag for nested same-name elements
                                         const closeTag = `</${tag}>`;
-                                        const closeIdx = html.toLowerCase().indexOf(closeTag, i);
-                                        if (closeIdx !== -1) {
-                                            i = closeIdx + closeTag.length;
+                                        const openTag = `<${tag}`;
+                                        let searchPos = i;
+                                        let depth = 1;
+                                        while (searchPos < html.length && depth > 0) {
+                                            const nextOpen = html.toLowerCase().indexOf(openTag, searchPos);
+                                            const nextClose = html.toLowerCase().indexOf(closeTag, searchPos);
+                                            if (nextClose === -1) {
+                                                searchPos = html.length;
+                                                break;
+                                            }
+                                            if (nextOpen !== -1 && nextOpen < nextClose) {
+                                                // Check it's a real open tag (followed by space, >, or /)
+                                                const afterOpen = html[nextOpen + openTag.length];
+                                                if (afterOpen === ' ' || afterOpen === '>' || afterOpen === '/' || afterOpen === undefined) {
+                                                    depth++;
+                                                }
+                                                searchPos = nextOpen + openTag.length;
+                                            }
+                                            else {
+                                                depth--;
+                                                if (depth === 0) {
+                                                    searchPos = nextClose;
+                                                    break;
+                                                }
+                                                searchPos = nextClose + closeTag.length;
+                                            }
+                                        }
+                                        if (depth === 0) {
+                                            i = searchPos + closeTag.length;
                                         }
                                         else {
                                             i = html.length;
@@ -1382,13 +1450,40 @@ function makePrelude(env) {
                 // --- YAML natives ---
                 case "yaml.parse": {
                     const src = args[0];
+                    function flowSplit(inner) {
+                        const parts = [];
+                        let depth = 0, start = 0, inStr = false, strCh = "";
+                        for (let i = 0; i < inner.length; i++) {
+                            const ch = inner[i];
+                            if (inStr) {
+                                if (ch === strCh && inner[i - 1] !== "\\")
+                                    inStr = false;
+                                continue;
+                            }
+                            if (ch === '"' || ch === "'") {
+                                inStr = true;
+                                strCh = ch;
+                                continue;
+                            }
+                            if (ch === "{" || ch === "[")
+                                depth++;
+                            else if (ch === "}" || ch === "]")
+                                depth--;
+                            else if (ch === "," && depth === 0) {
+                                parts.push(inner.slice(start, i));
+                                start = i + 1;
+                            }
+                        }
+                        if (inner.slice(start).trim() !== "")
+                            parts.push(inner.slice(start));
+                        return parts;
+                    }
                     function yamlParseFlowMapping(s) {
                         const inner = s.slice(1, -1).trim();
                         const m = new Map();
                         if (inner === "")
                             return m;
-                        // Simple comma-split (doesn't handle nested structures)
-                        const parts = inner.split(",");
+                        const parts = flowSplit(inner);
                         for (const part of parts) {
                             const colon = part.indexOf(":");
                             if (colon > 0) {
@@ -1401,10 +1496,16 @@ function makePrelude(env) {
                         const inner = s.slice(1, -1).trim();
                         if (inner === "")
                             return [];
-                        return inner.split(",").map(x => yamlParseValue(x.trim()));
+                        return flowSplit(inner).map(x => yamlParseValue(x.trim()));
                     }
                     function yamlParseValue(s) {
                         s = s.trim();
+                        // Strip inline comments from unquoted values (bug #1)
+                        if (s !== "" && !s.startsWith('"') && !s.startsWith("'") && !s.startsWith("{") && !s.startsWith("[")) {
+                            const hashIdx = s.indexOf(" #");
+                            if (hashIdx >= 0)
+                                s = s.slice(0, hashIdx).trim();
+                        }
                         if (s === "" || s === "~" || s === "null")
                             return null;
                         if (s === "true" || s === "True" || s === "TRUE" || s === "yes" || s === "Yes" || s === "YES" || s === "on" || s === "On" || s === "ON")
@@ -1592,7 +1693,7 @@ function makePrelude(env) {
                             return result;
                         }
                     }
-                    const rawLines = src.split("\n").filter(l => !l.trimStart().startsWith("#"));
+                    const rawLines = src.split("\n").filter(l => !l.trimStart().startsWith("#") && l.trim() !== "---" && l.trim() !== "...");
                     return toArcValue(yamlParse(rawLines, 0));
                 }
                 case "yaml.stringify": {
@@ -1647,12 +1748,16 @@ function makePrelude(env) {
                     let current = root;
                     const lines = src.split("\n");
                     function tomlStripComment(s) {
-                        // Strip inline comments (not inside strings)
+                        // Strip inline comments (not inside strings), handling escapes properly
                         let inStr = false;
                         let strCh = "";
                         for (let i = 0; i < s.length; i++) {
                             if (inStr) {
-                                if (s[i] === strCh && s[i - 1] !== "\\")
+                                if (s[i] === "\\") {
+                                    i++;
+                                    continue;
+                                } // skip escaped char (handles \\ and \")
+                                if (s[i] === strCh)
                                     inStr = false;
                                 continue;
                             }
@@ -1666,12 +1771,51 @@ function makePrelude(env) {
                         }
                         return s;
                     }
+                    function tomlExtractString(s) {
+                        // Walk char by char to find closing quote, handling \" escapes
+                        let result = "";
+                        for (let i = 1; i < s.length; i++) {
+                            if (s[i] === "\\") {
+                                if (i + 1 < s.length) {
+                                    const next = s[i + 1];
+                                    if (next === '"') {
+                                        result += '"';
+                                        i++;
+                                    }
+                                    else if (next === '\\') {
+                                        result += '\\';
+                                        i++;
+                                    }
+                                    else if (next === 'n') {
+                                        result += '\n';
+                                        i++;
+                                    }
+                                    else if (next === 't') {
+                                        result += '\t';
+                                        i++;
+                                    }
+                                    else {
+                                        result += s[i];
+                                    }
+                                }
+                            }
+                            else if (s[i] === '"') {
+                                return result;
+                            }
+                            else {
+                                result += s[i];
+                            }
+                        }
+                        return result;
+                    }
                     function tomlParseValue(s) {
                         s = tomlStripComment(s).trim();
                         if (s === "true")
                             return true;
                         if (s === "false")
                             return false;
+                        if (s === "True" || s === "False")
+                            return s; // bug #6: reject capitalized booleans
                         if (s === "inf" || s === "+inf")
                             return Infinity;
                         if (s === "-inf")
@@ -1690,14 +1834,28 @@ function makePrelude(env) {
                             if (end !== -1)
                                 return s.slice(3, end).replace(/^\n/, "");
                         }
-                        if (s.startsWith('"') && s.endsWith('"'))
-                            return s.slice(1, -1).replace(/\\n/g, "\n").replace(/\\t/g, "\t").replace(/\\\\/g, "\\");
+                        if (s.startsWith('"'))
+                            return tomlExtractString(s); // bug #3: handle escaped quotes
                         if (s.startsWith("'") && s.endsWith("'"))
                             return s.slice(1, -1);
-                        if (/^-?\d+$/.test(s))
-                            return parseInt(s, 10);
-                        if (/^-?\d+\.\d+$/.test(s))
-                            return parseFloat(s);
+                        // bug #7: ISO 8601 datetime
+                        if (/^\d{4}-\d{2}-\d{2}([T ]\d{2}:\d{2}(:\d{2})?)?/.test(s)) {
+                            const t = new Date(s).getTime();
+                            if (!isNaN(t))
+                                return t;
+                        }
+                        // bug #8: hex/octal/binary integers
+                        if (/^0x[0-9a-fA-F_]+$/.test(s))
+                            return parseInt(s.replace(/_/g, ""), 16);
+                        if (/^0o[0-7_]+$/.test(s))
+                            return parseInt(s.replace(/_/g, "").replace("0o", ""), 8);
+                        if (/^0b[01_]+$/.test(s))
+                            return parseInt(s.replace(/_/g, "").replace("0b", ""), 2);
+                        // bug #8: integers with underscores
+                        if (/^[+-]?\d[\d_]*$/.test(s))
+                            return parseInt(s.replace(/_/g, ""), 10);
+                        if (/^[+-]?\d[\d_]*\.[\d_]+$/.test(s))
+                            return parseFloat(s.replace(/_/g, ""));
                         if (s.startsWith("["))
                             return tomlParseArray(s);
                         if (s.startsWith("{"))
@@ -1787,6 +1945,7 @@ function makePrelude(env) {
                         }
                         return cur;
                     }
+                    const seenSections = new Set(); // bug #9
                     for (let li = 0; li < lines.length; li++) {
                         const trimmed = lines[li].trim();
                         if (trimmed === "" || trimmed.startsWith("#"))
@@ -1806,7 +1965,11 @@ function makePrelude(env) {
                         }
                         const secMatch = trimmed.match(/^\[([^\]]+)\]$/);
                         if (secMatch) {
-                            const keys = secMatch[1].split(".").map((k) => k.trim());
+                            const secKey = secMatch[1].trim();
+                            if (seenSections.has(secKey))
+                                throw new Error(`Duplicate TOML section: [${secKey}]`);
+                            seenSections.add(secKey);
+                            const keys = secKey.split(".").map((k) => k.trim());
                             current = ensurePath(root, keys);
                             continue;
                         }
@@ -1836,6 +1999,31 @@ function makePrelude(env) {
                                     valStr += "\n" + lines[li];
                                 }
                             }
+                            // Bug #5: Handle multiline arrays
+                            if (valStr.startsWith("[") && !valStr.startsWith("[[")) {
+                                let depth = 0;
+                                for (const ch of valStr) {
+                                    if (ch === "[")
+                                        depth++;
+                                    else if (ch === "]")
+                                        depth--;
+                                }
+                                while (depth > 0 && li + 1 < lines.length) {
+                                    li++;
+                                    const cont = lines[li].trim();
+                                    if (cont === "" || cont.startsWith("#")) {
+                                        valStr += " ";
+                                        continue;
+                                    }
+                                    valStr += " " + cont;
+                                    for (const ch of cont) {
+                                        if (ch === "[")
+                                            depth++;
+                                        else if (ch === "]")
+                                            depth--;
+                                    }
+                                }
+                            }
                             const val = tomlParseValue(valStr);
                             // Expand dotted keys: a.b.c = 1 → nested maps
                             if (key.includes(".")) {
@@ -1965,6 +2153,16 @@ function makePrelude(env) {
                     const level = args[0];
                     const msg = args[1];
                     const fields = args[2];
+                    // Bug #12: validate level
+                    const validLogLevels = ["debug", "info", "warn", "error", "fatal"];
+                    if (!validLogLevels.includes(level)) {
+                        throw new ArcRuntimeError(`Invalid log level '${level}'. Must be one of: ${validLogLevels.join(", ")}`, { code: ErrorCode.UNDEFINED_VARIABLE });
+                    }
+                    // Bug #11: check level threshold
+                    const li = validLogLevels.indexOf(level);
+                    const mi = validLogLevels.indexOf(globalThis.__arc_log_level ?? "debug");
+                    if (li < mi)
+                        return null;
                     const obj = {
                         timestamp: new Date().toISOString(),
                         level: level,
@@ -2105,7 +2303,7 @@ function makePrelude(env) {
     };
     function callFn(fn, args) {
         if (fn && typeof fn === "object" && "__fn" in fn) {
-            if (++callDepth > 10000) {
+            if (++callDepth > 2000) {
                 callDepth = 0;
                 throw new ArcRuntimeError("Maximum call stack depth exceeded");
             }
@@ -2325,7 +2523,7 @@ function evalExpr(expr, env) {
             }
             else if (callee && typeof callee === "object" && "__fn" in callee) {
                 let fn = callee;
-                if (++callDepth > 10000) {
+                if (++callDepth > 2000) {
                     callDepth = 0;
                     throw new ArcRuntimeError("Maximum call stack depth exceeded");
                 }
@@ -2334,7 +2532,7 @@ function evalExpr(expr, env) {
                 let tcoIterations = 0;
                 try {
                     tailLoop: while (true) {
-                        if (++tcoIterations > 10000) {
+                        if (++tcoIterations > 2000) {
                             callDepth--;
                             throw new ArcRuntimeError("Maximum call stack depth exceeded");
                         }
@@ -2411,10 +2609,16 @@ function evalExpr(expr, env) {
         case "IndexExpr": {
             const obj = evalExpr(expr.object, env);
             const idx = evalExpr(expr.index, env);
-            if (typeof obj === "string" && typeof idx === "number")
-                return idx >= 0 && idx < obj.length ? obj.charAt(idx) : null;
-            if (Array.isArray(obj) && typeof idx === "number")
-                return obj[idx] ?? null;
+            if (typeof obj === "string" && typeof idx === "number") {
+                if (idx !== Math.floor(idx))
+                    throw new ArcRuntimeError("String index must be an integer");
+                let i = idx < 0 ? obj.length + idx : idx;
+                return i >= 0 && i < obj.length ? obj.charAt(i) : null;
+            }
+            if (Array.isArray(obj) && typeof idx === "number") {
+                let i = idx < 0 ? obj.length + idx : idx;
+                return obj[i] ?? null;
+            }
             if (obj && typeof obj === "object" && "__map" in obj) {
                 const key = typeof idx === "string" ? idx : toStr(idx);
                 return obj.entries.get(key) ?? null;

package/dist/parser.js

@@ -169,6 +169,8 @@ export class Parser {
             if (this.at(TokenType.DotDotDot)) {
                 this.advance();
                 const pname = this.expect(TokenType.Ident).value;
+                if (params.includes(pname))
+                    throw new ParseError(`Duplicate parameter name '${pname}'`, this.loc());
                 params.push(pname);
                 richParams.push({ name: pname, rest: true });
                 hasRichParams = true;
@@ -176,6 +178,8 @@ export class Parser {
                 break;
             }
             const pname = this.expect(TokenType.Ident).value;
+            if (params.includes(pname))
+                throw new ParseError(`Duplicate parameter name '${pname}'`, this.loc());
             params.push(pname);
             if (this.at(TokenType.Assign)) {
                 this.advance();

package/dist/version.d.ts

@@ -1,4 +1,4 @@
-export declare const ARC_VERSION = "0.6.1";
+export declare const ARC_VERSION = "0.6.2";
 export declare const ARC_BUILD_DATE: string;
 export declare const ARC_PLATFORM: string;
 /** Print version info */

package/dist/version.js

@@ -1,5 +1,5 @@
 // Arc Version System
-export const ARC_VERSION = "0.6.1";
+export const ARC_VERSION = "0.6.2";
 export const ARC_BUILD_DATE = new Date().toISOString().split("T")[0];
 export const ARC_PLATFORM = `${process.platform}-${process.arch}`;
 /** Print version info */

package/package.json

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