arc-lang 0.6.0 → 0.6.2

package/dist/interpreter.js

@@ -170,6 +170,7 @@ function jsToArc(v) {
     }
     return String(v);
 }
+let callDepth = 0;
 function resolveAsync(v) {
     if (v && typeof v === "object" && "__async" in v) {
         return v.thunk();
@@ -201,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))
@@ -248,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 [];
@@ -261,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,
@@ -328,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;
@@ -356,13 +357,16 @@ function makePrelude(env) {
         time_ms: () => Date.now(),
         // --- crypto natives ---
         crypto_hash: (algorithm, data) => {
-            return nodeCrypto.createHash(algorithm).update(data).digest("hex");
+            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) => {
@@ -371,8 +375,8 @@ function makePrelude(env) {
             return nodeCrypto.randomInt(lo, hi + 1);
         },
         crypto_uuid: () => nodeCrypto.randomUUID(),
-        crypto_encode_base64: (s) => Buffer.from(s).toString("base64"),
-        crypto_decode_base64: (s) => Buffer.from(s, "base64").toString("utf-8"),
+        crypto_encode_base64: (s) => Buffer.from(s == null ? "" : s).toString("base64"),
+        crypto_decode_base64: (s) => s == null ? "" : Buffer.from(s, "base64").toString("utf-8"),
         // --- net natives ---
         net_url_parse: (url) => {
             try {
@@ -391,12 +395,32 @@ function makePrelude(env) {
             }
         },
         net_url_encode: (s) => encodeURIComponent(s),
-        net_url_decode: (s) => decodeURIComponent(s),
+        net_url_decode: (s) => { try {
+            return decodeURIComponent(s);
+        }
+        catch {
+            return null;
+        } },
         net_query_parse: (s) => {
+            if (s == null)
+                return { __map: true, entries: new Map() };
             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) => {
@@ -409,11 +433,13 @@ function makePrelude(env) {
             return "";
         },
         net_ip_is_valid: (s) => {
+            if (s == null)
+                return false;
             const str = s;
             // 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 {
@@ -455,40 +481,45 @@ function makePrelude(env) {
         },
         error_try: (fn) => {
             try {
-                const result = typeof fn === "function" ? fn() :
-                    (fn && typeof fn === "object" && "__fn" in fn) ? callFn(fn, []) : null;
+                if (typeof fn !== "function" && !(fn && typeof fn === "object" && "__fn" in fn)) {
+                    const errMap = new Map();
+                    errMap.set("ok", false);
+                    errMap.set("error", "argument is not a function");
+                    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;
@@ -519,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
             }
@@ -551,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);
@@ -664,7 +700,8 @@ function makePrelude(env) {
             const fmt = format;
             // Support ISO format and custom format tokens
             if (fmt === "ISO" || fmt === "iso") {
-                return new Date(s).getTime();
+                const t = new Date(s).getTime();
+                return isNaN(t) ? null : t;
             }
             // Parse using format tokens: YYYY, MM, DD, hh, mm, ss
             let year = 2000, month = 1, day = 1, hour = 0, min = 0, sec = 0;
@@ -705,21 +742,28 @@ function makePrelude(env) {
                     si++;
                 }
             }
-            return new Date(year, month - 1, day, hour, min, sec).getTime();
+            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);
             let result = fmt;
-            result = result.replace("YYYY", String(d.getFullYear()));
-            result = result.replace("MM", String(d.getMonth() + 1).padStart(2, "0"));
-            result = result.replace("DD", String(d.getDate()).padStart(2, "0"));
-            result = result.replace("hh", String(d.getHours()).padStart(2, "0"));
-            result = result.replace("mm", String(d.getMinutes()).padStart(2, "0"));
-            result = result.replace("ss", String(d.getSeconds()).padStart(2, "0"));
+            result = result.replaceAll("YYYY", String(d.getFullYear()));
+            result = result.replaceAll("MM", String(d.getMonth() + 1).padStart(2, "0"));
+            result = result.replaceAll("DD", String(d.getDate()).padStart(2, "0"));
+            result = result.replaceAll("hh", String(d.getHours()).padStart(2, "0"));
+            result = result.replaceAll("mm", String(d.getMinutes()).padStart(2, "0"));
+            result = result.replaceAll("ss", String(d.getSeconds()).padStart(2, "0"));
             return result;
         },
         __builtin_date_to_iso: (ts) => new Date(ts).toISOString(),
-        __builtin_date_from_iso: (s) => new Date(s).getTime(),
+        __builtin_date_from_iso: (s) => { const t = new Date(s).getTime(); return isNaN(t) ? null : t; },
         // --- os natives ---
         __native: (name, ...args) => {
             const cmd = name;
@@ -737,6 +781,13 @@ function makePrelude(env) {
                         entries.set(k, toArcValue(val));
                     return { __map: true, entries };
                 }
+                if (typeof v === "object" && v !== null && !("__map" in v)) {
+                    // Convert plain objects to MapValue to prevent re-evaluation as Arc code
+                    const entries = new Map();
+                    for (const [k, val] of Object.entries(v))
+                        entries.set(k, toArcValue(val));
+                    return { __map: true, entries };
+                }
                 return v;
             }
             // Convert Arc MapValue back to raw Maps for stringifying
@@ -774,7 +825,6 @@ function makePrelude(env) {
                 case "os.temp_dir": return nodeOs.tmpdir();
                 case "os.list_dir": {
                     try {
-                        const fs = require("fs");
                         return nodeFs.readdirSync(args[0]);
                     }
                     catch {
@@ -783,7 +833,6 @@ function makePrelude(env) {
                 }
                 case "os.is_file": {
                     try {
-                        const fs = require("fs");
                         return nodeFs.statSync(args[0]).isFile();
                     }
                     catch {
@@ -792,7 +841,6 @@ function makePrelude(env) {
                 }
                 case "os.is_dir": {
                     try {
-                        const fs = require("fs");
                         return nodeFs.statSync(args[0]).isDirectory();
                     }
                     catch {
@@ -801,7 +849,6 @@ function makePrelude(env) {
                 }
                 case "os.mkdir": {
                     try {
-                        const fs = require("fs");
                         nodeFs.mkdirSync(args[0], { recursive: true });
                         return true;
                     }
@@ -811,7 +858,6 @@ function makePrelude(env) {
                 }
                 case "os.rmdir": {
                     try {
-                        const fs = require("fs");
                         nodeFs.rmdirSync(args[0]);
                         return true;
                     }
@@ -821,7 +867,6 @@ function makePrelude(env) {
                 }
                 case "os.remove": {
                     try {
-                        const fs = require("fs");
                         nodeFs.unlinkSync(args[0]);
                         return true;
                     }
@@ -831,7 +876,6 @@ function makePrelude(env) {
                 }
                 case "os.rename": {
                     try {
-                        const fs = require("fs");
                         nodeFs.renameSync(args[0], args[1]);
                         return true;
                     }
@@ -841,7 +885,6 @@ function makePrelude(env) {
                 }
                 case "os.copy": {
                     try {
-                        const fs = require("fs");
                         nodeFs.copyFileSync(args[0], args[1]);
                         return true;
                     }
@@ -851,7 +894,6 @@ function makePrelude(env) {
                 }
                 case "os.file_size": {
                     try {
-                        const fs = require("fs");
                         return nodeFs.statSync(args[0]).size;
                     }
                     catch {
@@ -861,40 +903,59 @@ function makePrelude(env) {
                 case "os.exec": {
                     try {
                         const cmd = args[0];
-                        // Command injection protection: reject commands with common shell injection patterns
-                        const dangerous = /[;&|`$]|\$\(|>\s*>|<\s*<|\beval\b|\bsource\b/;
+                        // Command injection protection: block backticks and $() subshells
+                        const dangerous = /`|\$\(|>\s*>|<\s*<|\beval\b|\bsource\b/;
                         if (dangerous.test(cmd)) {
                             throw new Error(`Potentially unsafe command (injection risk): ${cmd}`);
                         }
-                        const cp = require("child_process");
-                        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;
                     }
                 }
+                case "regex.escape": {
+                    const s = String(args[0] ?? "");
+                    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+                }
+                case "time.now": return Date.now();
+                case "time.sleep": {
+                    const ms = args[0];
+                    if (ms > 0) {
+                        const end = Date.now() + ms;
+                        while (Date.now() < end) { /* busy wait */ }
+                    }
+                    return null;
+                }
                 // --- 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] ?? "");
                     const maxTokens = args[1];
+                    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 : [""];
                 }
@@ -970,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];
@@ -1013,6 +1079,64 @@ function makePrelude(env) {
                 case "math.exp": return Math.exp(args[0]);
                 case "math.hypot": return Math.hypot(args[0], args[1]);
                 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 === "")
+                        return [];
+                    const rows = [];
+                    let i = 0;
+                    while (i < text.length) {
+                        const row = [];
+                        while (true) {
+                            let value = "";
+                            if (i < text.length && text[i] === '"') {
+                                i++; // skip opening quote
+                                while (i < text.length) {
+                                    if (text[i] === '"') {
+                                        if (i + 1 < text.length && text[i + 1] === '"') {
+                                            value += '"';
+                                            i += 2;
+                                        }
+                                        else {
+                                            i++; // skip closing quote
+                                            break;
+                                        }
+                                    }
+                                    else {
+                                        value += text[i];
+                                        i++;
+                                    }
+                                }
+                            }
+                            else {
+                                while (i < text.length && text[i] !== ',' && text[i] !== '\n' && text[i] !== '\r') {
+                                    value += text[i];
+                                    i++;
+                                }
+                            }
+                            row.push(value);
+                            if (i < text.length && text[i] === ',') {
+                                i++;
+                            }
+                            else {
+                                break;
+                            }
+                        }
+                        // skip line ending
+                        if (i < text.length && text[i] === '\r')
+                            i++;
+                        if (i < text.length && text[i] === '\n')
+                            i++;
+                        rows.push(row);
+                    }
+                    return rows;
+                }
                 // --- html natives ---
                 case "html.parse": {
                     const src = args[0];
@@ -1023,7 +1147,9 @@ function makePrelude(env) {
                         return m;
                     }
                     function decodeEntities(s) {
-                        return s.replace(/&amp;/g, '&').replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&quot;/g, '"').replace(/&#39;/g, "'");
+                        return s.replace(/&#x([0-9a-fA-F]+);/g, (_, h) => String.fromCodePoint(parseInt(h, 16)))
+                            .replace(/&#(\d+);/g, (_, d) => String.fromCodePoint(parseInt(d, 10)))
+                            .replace(/&amp;/g, '&').replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&quot;/g, '"').replace(/&#39;/g, "'");
                     }
                     function parseHTML(html) {
                         const nodes = [];
@@ -1033,6 +1159,18 @@ function makePrelude(env) {
                                 if (html[i + 1] === '/') {
                                     break;
                                 }
+                                // Skip comments
+                                if (html.slice(i, i + 4) === '<!--') {
+                                    const endComment = html.indexOf('-->', i + 4);
+                                    i = endComment !== -1 ? endComment + 3 : html.length;
+                                    continue;
+                                }
+                                // Skip DOCTYPE
+                                if (html.slice(i, i + 9).toLowerCase() === '<!doctype') {
+                                    const endDoc = html.indexOf('>', i);
+                                    i = endDoc !== -1 ? endDoc + 1 : html.length;
+                                    continue;
+                                }
                                 const tagMatch = html.slice(i).match(/^<([a-zA-Z][a-zA-Z0-9]*)/);
                                 if (!tagMatch) {
                                     nodes.push(decodeEntities(html[i]));
@@ -1088,15 +1226,59 @@ function makePrelude(env) {
                                 i++;
                                 const voidTags = new Set(['br', 'hr', 'img', 'input', 'meta', 'link', 'area', 'base', 'col', 'embed', 'source', 'track', 'wbr']);
                                 let children = [];
+                                const rawTags = new Set(['script', 'style']);
                                 if (!selfClosing && !voidTags.has(tag)) {
-                                    children = parseHTML(html.slice(i));
-                                    const closeTag = `</${tag}>`;
-                                    const closeIdx = html.toLowerCase().indexOf(closeTag, i);
-                                    if (closeIdx !== -1) {
-                                        i = closeIdx + closeTag.length;
+                                    if (rawTags.has(tag)) {
+                                        // Treat script/style content as raw text — don't parse inner content
+                                        const closeTag = `</${tag}>`;
+                                        const closeIdx = html.toLowerCase().indexOf(closeTag, i);
+                                        if (closeIdx !== -1) {
+                                            const rawText = html.slice(i, closeIdx);
+                                            if (rawText.trim())
+                                                children = [rawText];
+                                            i = closeIdx + closeTag.length;
+                                        }
+                                        else {
+                                            i = html.length;
+                                        }
                                     }
                                     else {
-                                        i = html.length;
+                                        children = parseHTML(html.slice(i));
+                                        // Bug #13: use depth counter to find correct closing tag for nested same-name elements
+                                        const closeTag = `</${tag}>`;
+                                        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;
+                                        }
                                     }
                                 }
                                 nodes.push(mkMap([['tag', tag], ['attrs', mkMap(attrEntries)], ['children', children]]));
@@ -1231,7 +1413,12 @@ function makePrelude(env) {
                 case "env.get": return process.env[args[0]] ?? null;
                 case "env.get_or": return process.env[args[0]] ?? args[1];
                 case "env.set": {
-                    process.env[args[0]] = String(args[1]);
+                    if (args[1] == null) {
+                        delete process.env[args[0]];
+                    }
+                    else {
+                        process.env[args[0]] = String(args[1]);
+                    }
                     return null;
                 }
                 case "env.remove": {
@@ -1263,13 +1450,67 @@ 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;
+                        const parts = flowSplit(inner);
+                        for (const part of parts) {
+                            const colon = part.indexOf(":");
+                            if (colon > 0) {
+                                m.set(part.slice(0, colon).trim(), yamlParseValue(part.slice(colon + 1).trim()));
+                            }
+                        }
+                        return m;
+                    }
+                    function yamlParseFlowSequence(s) {
+                        const inner = s.slice(1, -1).trim();
+                        if (inner === "")
+                            return [];
+                        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")
+                        if (s === "true" || s === "True" || s === "TRUE" || s === "yes" || s === "Yes" || s === "YES" || s === "on" || s === "On" || s === "ON")
                             return true;
-                        if (s === "false" || s === "False" || s === "FALSE")
+                        if (s === "false" || s === "False" || s === "FALSE" || s === "no" || s === "No" || s === "NO" || s === "off" || s === "Off" || s === "OFF")
                             return false;
                         if (/^-?\d+$/.test(s))
                             return parseInt(s, 10);
@@ -1277,6 +1518,10 @@ function makePrelude(env) {
                             return parseFloat(s);
                         if ((s.startsWith('"') && s.endsWith('"')) || (s.startsWith("'") && s.endsWith("'")))
                             return s.slice(1, -1);
+                        if (s.startsWith("{") && s.endsWith("}"))
+                            return yamlParseFlowMapping(s);
+                        if (s.startsWith("[") && s.endsWith("]"))
+                            return yamlParseFlowSequence(s);
                         return s;
                     }
                     function yamlParse(lines, baseIndent) {
@@ -1300,13 +1545,36 @@ function makePrelude(env) {
                                     continue;
                                 }
                                 const lt = line.trimStart();
-                                if (!lt.startsWith("- ")) {
+                                if (!lt.startsWith("- ") && lt !== "-") {
                                     i++;
                                     continue;
                                 }
-                                const itemVal = lt.slice(2);
+                                const itemVal = lt === "-" ? "" : lt.slice(2);
                                 const lineIndent = line.length - line.trimStart().length;
                                 const childIndent = lineIndent + 2;
+                                // Handle nested list: `- - val`
+                                if (itemVal.startsWith("- ") || itemVal === "-") {
+                                    const nestedLines = [" ".repeat(childIndent) + itemVal];
+                                    let j = i + 1;
+                                    while (j < lines.length) {
+                                        const cl = lines[j];
+                                        if (cl.trim() === "") {
+                                            nestedLines.push(cl);
+                                            j++;
+                                            continue;
+                                        }
+                                        const ci = cl.length - cl.trimStart().length;
+                                        if (ci >= childIndent) {
+                                            nestedLines.push(lines[j]);
+                                            j++;
+                                        }
+                                        else
+                                            break;
+                                    }
+                                    result.push(yamlParse(nestedLines, childIndent));
+                                    i = j;
+                                    continue;
+                                }
                                 const children = [];
                                 let j = i + 1;
                                 while (j < lines.length) {
@@ -1324,7 +1592,11 @@ function makePrelude(env) {
                                     else
                                         break;
                                 }
-                                if (children.length > 0 && children.some(c => c.trim() !== "" && c.trimStart().match(/^[^:]+:\s/))) {
+                                if (itemVal.trim() === "" && children.length === 0) {
+                                    // Empty list item: `- ` or bare `-`
+                                    result.push(null);
+                                }
+                                else if (children.length > 0 && children.some(c => c.trim() !== "" && c.trimStart().match(/^[^:]+:\s/))) {
                                     if (itemVal.trim() !== "") {
                                         const allLines = [" ".repeat(childIndent) + itemVal, ...children];
                                         result.push(yamlParse(allLines, childIndent));
@@ -1403,10 +1675,14 @@ function makePrelude(env) {
                                         else
                                             break;
                                     }
-                                    const childIndent = children.length > 0 ?
-                                        (children.find(c => c.trim() !== "")?.length ?? indent + 2) - (children.find(c => c.trim() !== "")?.trimStart().length ?? 0) :
-                                        indent + 2;
-                                    result.set(key, yamlParse(children, childIndent));
+                                    if (children.length === 0 || children.every(c => c.trim() === "")) {
+                                        // No children → nil, not empty map
+                                        result.set(key, null);
+                                    }
+                                    else {
+                                        const childIndent = (children.find(c => c.trim() !== "")?.length ?? indent + 2) - (children.find(c => c.trim() !== "")?.trimStart().length ?? 0);
+                                        result.set(key, yamlParse(children, childIndent));
+                                    }
                                     i = j;
                                 }
                                 else {
@@ -1417,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": {
@@ -1471,20 +1747,115 @@ function makePrelude(env) {
                     const root = new Map();
                     let current = root;
                     const lines = src.split("\n");
+                    function tomlStripComment(s) {
+                        // 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] === "\\") {
+                                    i++;
+                                    continue;
+                                } // skip escaped char (handles \\ and \")
+                                if (s[i] === strCh)
+                                    inStr = false;
+                                continue;
+                            }
+                            if (s[i] === '"' || s[i] === "'") {
+                                inStr = true;
+                                strCh = s[i];
+                                continue;
+                            }
+                            if (s[i] === "#")
+                                return s.slice(0, i).trim();
+                        }
+                        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 = s.trim();
+                        s = tomlStripComment(s).trim();
                         if (s === "true")
                             return true;
                         if (s === "false")
                             return false;
-                        if (s.startsWith('"') && s.endsWith('"'))
-                            return s.slice(1, -1).replace(/\\n/g, "\n").replace(/\\t/g, "\t").replace(/\\\\/g, "\\");
+                        if (s === "True" || s === "False")
+                            return s; // bug #6: reject capitalized booleans
+                        if (s === "inf" || s === "+inf")
+                            return Infinity;
+                        if (s === "-inf")
+                            return -Infinity;
+                        if (s === "nan" || s === "+nan" || s === "-nan")
+                            return NaN;
+                        // Multiline basic strings
+                        if (s.startsWith('"""')) {
+                            const end = s.indexOf('"""', 3);
+                            if (end !== -1)
+                                return s.slice(3, end).replace(/^\n/, "").replace(/\\n/g, "\n").replace(/\\t/g, "\t").replace(/\\\\/g, "\\");
+                        }
+                        // Multiline literal strings
+                        if (s.startsWith("'''")) {
+                            const end = s.indexOf("'''", 3);
+                            if (end !== -1)
+                                return s.slice(3, end).replace(/^\n/, "");
+                        }
+                        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("{"))
@@ -1574,8 +1945,9 @@ function makePrelude(env) {
                         }
                         return cur;
                     }
-                    for (const line of lines) {
-                        const trimmed = line.trim();
+                    const seenSections = new Set(); // bug #9
+                    for (let li = 0; li < lines.length; li++) {
+                        const trimmed = lines[li].trim();
                         if (trimmed === "" || trimmed.startsWith("#"))
                             continue;
                         const arrMatch = trimmed.match(/^\[\[([^\]]+)\]\]$/);
@@ -1593,15 +1965,80 @@ 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;
                         }
                         const eq = trimmed.indexOf("=");
                         if (eq > 0) {
                             const key = trimmed.slice(0, eq).trim();
-                            const val = tomlParseValue(trimmed.slice(eq + 1));
-                            current.set(key, val);
+                            let valStr = trimmed.slice(eq + 1).trim();
+                            // Handle multiline basic strings
+                            if (valStr.startsWith('"""') && !valStr.slice(3).includes('"""')) {
+                                while (li + 1 < lines.length && !lines[li + 1].includes('"""')) {
+                                    li++;
+                                    valStr += "\n" + lines[li];
+                                }
+                                if (li + 1 < lines.length) {
+                                    li++;
+                                    valStr += "\n" + lines[li];
+                                }
+                            }
+                            // Handle multiline literal strings
+                            if (valStr.startsWith("'''") && !valStr.slice(3).includes("'''")) {
+                                while (li + 1 < lines.length && !lines[li + 1].includes("'''")) {
+                                    li++;
+                                    valStr += "\n" + lines[li];
+                                }
+                                if (li + 1 < lines.length) {
+                                    li++;
+                                    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(".")) {
+                                const parts = key.split(".").map(k => k.trim());
+                                let target = current;
+                                for (let ki = 0; ki < parts.length - 1; ki++) {
+                                    if (!target.has(parts[ki]))
+                                        target.set(parts[ki], new Map());
+                                    target = target.get(parts[ki]);
+                                }
+                                target.set(parts[parts.length - 1], val);
+                            }
+                            else {
+                                current.set(key, val);
+                            }
                         }
                     }
                     return toArcValue(root);
@@ -1661,6 +2098,10 @@ function makePrelude(env) {
                         }
                         return lines.join("\n");
                     }
+                    if (val === null || val === undefined)
+                        return "";
+                    if (!(val instanceof Map))
+                        return "";
                     return tomlStringifySection(val, "");
                 }
                 // --- log natives ---
@@ -1697,7 +2138,12 @@ function makePrelude(env) {
                     return null;
                 }
                 case "log.set_level": {
-                    globalThis.__arc_log_level = args[0];
+                    const lvl = args[0];
+                    const validLevels = ["debug", "info", "warn", "error", "fatal"];
+                    if (!validLevels.includes(lvl)) {
+                        throw new ArcRuntimeError(`Invalid log level '${lvl}'. Must be one of: ${validLevels.join(", ")}`, { code: ErrorCode.UNDEFINED_VARIABLE });
+                    }
+                    globalThis.__arc_log_level = lvl;
                     return null;
                 }
                 case "log.with": {
@@ -1707,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,
@@ -1726,6 +2182,8 @@ function makePrelude(env) {
         embed_dot_product: (a, b) => {
             if (!Array.isArray(a) || !Array.isArray(b))
                 return 0;
+            if (a.length !== b.length)
+                throw new Error(`Vector length mismatch: ${a.length} vs ${b.length}`);
             let sum = 0;
             for (let i = 0; i < a.length; i++)
                 sum += a[i] * b[i];
@@ -1742,6 +2200,8 @@ function makePrelude(env) {
         embed_cosine_similarity: (a, b) => {
             if (!Array.isArray(a) || !Array.isArray(b))
                 return 0;
+            if (a.length !== b.length)
+                throw new Error(`Vector length mismatch: ${a.length} vs ${b.length}`);
             let dot = 0, magA = 0, magB = 0;
             for (let i = 0; i < a.length; i++) {
                 const ai = a[i], bi = b[i];
@@ -1766,6 +2226,8 @@ function makePrelude(env) {
         embed_euclidean_distance: (a, b) => {
             if (!Array.isArray(a) || !Array.isArray(b))
                 return 0;
+            if (a.length !== b.length)
+                throw new Error(`Vector length mismatch: ${a.length} vs ${b.length}`);
             let sum = 0;
             for (let i = 0; i < a.length; i++) {
                 const d = a[i] - b[i];
@@ -1841,13 +2303,20 @@ function makePrelude(env) {
     };
     function callFn(fn, args) {
         if (fn && typeof fn === "object" && "__fn" in fn) {
+            if (++callDepth > 2000) {
+                callDepth = 0;
+                throw new ArcRuntimeError("Maximum call stack depth exceeded");
+            }
             const f = fn;
             const fnEnv = new Env(f.closure);
             bindParams(f, args, fnEnv, evalExpr);
             try {
-                return evalExpr(f.body, fnEnv);
+                const result = evalExpr(f.body, fnEnv);
+                callDepth--;
+                return result;
             }
             catch (e) {
+                callDepth--;
                 if (e instanceof ReturnSignal)
                     return e.value;
                 throw e;
@@ -1974,13 +2443,31 @@ function evalExpr(expr, env) {
             switch (expr.op) {
                 case "+": {
                     if (typeof left === "string" || typeof right === "string") {
+                        if (left === null || right === null)
+                            throw new ArcRuntimeError(`TypeError: cannot add nil`, { code: ErrorCode.INVALID_OPERATOR, loc: expr.loc });
                         return toStr(left) + toStr(right);
                     }
+                    if (left === null || right === null)
+                        throw new ArcRuntimeError(`TypeError: cannot add nil`, { code: ErrorCode.INVALID_OPERATOR, loc: expr.loc });
+                    if (typeof left !== "number" || typeof right !== "number")
+                        throw new ArcRuntimeError(`TypeError: cannot add ${typeof left} and ${typeof right}`, { code: ErrorCode.INVALID_OPERATOR, loc: expr.loc });
                     return left + right;
                 }
-                case "-": return left - right;
-                case "*": return left * right;
+                case "-": {
+                    if (typeof left !== "number" || typeof right !== "number")
+                        throw new ArcRuntimeError(`TypeError: cannot subtract non-numbers`, { code: ErrorCode.INVALID_OPERATOR, loc: expr.loc });
+                    return left - right;
+                }
+                case "*": {
+                    if (typeof left === "string" && typeof right === "number" && Number.isInteger(right) && right >= 0)
+                        return left.repeat(right);
+                    if (typeof left !== "number" || typeof right !== "number")
+                        throw new ArcRuntimeError(`TypeError: cannot multiply non-numbers`, { code: ErrorCode.INVALID_OPERATOR, loc: expr.loc });
+                    return left * right;
+                }
                 case "/": {
+                    if (typeof left !== "number" || typeof right !== "number")
+                        throw new ArcRuntimeError(`TypeError: cannot divide non-numbers`, { code: ErrorCode.INVALID_OPERATOR, loc: expr.loc });
                     if (right === 0)
                         throw new ArcRuntimeError(`Division by zero`, {
                             code: ErrorCode.DIVISION_BY_ZERO, loc: expr.loc,
@@ -1989,6 +2476,8 @@ function evalExpr(expr, env) {
                     return left / right;
                 }
                 case "%": {
+                    if (typeof left !== "number" || typeof right !== "number")
+                        throw new ArcRuntimeError(`TypeError: cannot modulo non-numbers`, { code: ErrorCode.INVALID_OPERATOR, loc: expr.loc });
                     if (right === 0)
                         throw new ArcRuntimeError(`Modulo by zero`, {
                             code: ErrorCode.DIVISION_BY_ZERO, loc: expr.loc,
@@ -1996,7 +2485,11 @@ function evalExpr(expr, env) {
                         });
                     return left % right;
                 }
-                case "**": return Math.pow(left, right);
+                case "**": {
+                    if (typeof left !== "number" || typeof right !== "number")
+                        throw new ArcRuntimeError(`TypeError: cannot exponentiate non-numbers`, { code: ErrorCode.INVALID_OPERATOR, loc: expr.loc });
+                    return Math.pow(left, right);
+                }
                 case "==": return left === right;
                 case "!=": return left !== right;
                 case "<": return left < right;
@@ -2017,7 +2510,7 @@ function evalExpr(expr, env) {
             const operand = evalExpr(expr.operand, env);
             if (expr.op === "-")
                 return -operand;
-            if (expr.op === "not")
+            if (expr.op === "not" || expr.op === "!")
                 return !isTruthy(operand);
             throw new Error(`Unknown unary op: ${expr.op}`);
         }
@@ -2030,10 +2523,19 @@ function evalExpr(expr, env) {
             }
             else if (callee && typeof callee === "object" && "__fn" in callee) {
                 let fn = callee;
+                if (++callDepth > 2000) {
+                    callDepth = 0;
+                    throw new ArcRuntimeError("Maximum call stack depth exceeded");
+                }
                 // Tail call optimization loop: if the function body resolves to
                 // a tail call back to itself, reuse the frame instead of recursing
+                let tcoIterations = 0;
                 try {
                     tailLoop: while (true) {
+                        if (++tcoIterations > 2000) {
+                            callDepth--;
+                            throw new ArcRuntimeError("Maximum call stack depth exceeded");
+                        }
                         const fnEnv = new Env(fn.closure);
                         bindParams(fn, args, fnEnv, evalExpr);
                         const bodyResult = evalExprTCO(fn.body, fnEnv, fn.name);
@@ -2046,8 +2548,10 @@ function evalExpr(expr, env) {
                         result = bodyResult;
                         break;
                     }
+                    callDepth--;
                 }
                 catch (e) {
+                    callDepth--;
                     if (e instanceof ReturnSignal) {
                         result = e.value;
                     }
@@ -2105,8 +2609,16 @@ function evalExpr(expr, env) {
         case "IndexExpr": {
             const obj = evalExpr(expr.object, env);
             const idx = evalExpr(expr.index, env);
-            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;
@@ -2464,7 +2976,14 @@ export function interpret(program, onUse) {
             onUse(stmt, env);
         }
         else {
-            evalStmt(stmt, env);
+            try {
+                evalStmt(stmt, env);
+            }
+            catch (e) {
+                if (e instanceof ReturnSignal)
+                    throw new ArcRuntimeError("ret used outside of function");
+                throw e;
+            }
         }
     }
 }
@@ -2476,7 +2995,14 @@ export function interpretWithEnv(program, env, onUse) {
             result = null;
         }
         else {
-            result = evalStmt(stmt, env);
+            try {
+                result = evalStmt(stmt, env);
+            }
+            catch (e) {
+                if (e instanceof ReturnSignal)
+                    throw new ArcRuntimeError("ret used outside of function");
+                throw e;
+            }
         }
     }
     return result;

package/dist/lexer.js

@@ -377,6 +377,11 @@ export function lex(source) {
             tokens.push(tok(TokenType.Neq, "!=", sl, sc));
             continue;
         }
+        if (ch === "!") {
+            advance();
+            tokens.push(tok(TokenType.Not, "!", sl, sc));
+            continue;
+        }
         if (ch === "<" && peek(1) === "=") {
             advance();
             advance();

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.0";
+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.0";
+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.0",
+  "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": {