naider 1.16.0 → 1.17.1

package/README.md

@@ -1405,6 +1405,76 @@ naide pkg list                  # list installed NAIDE packages
 
 The `naide.pkg.json` manifest tracks NAIDE-specific metadata (main entry, exports, dependencies) while using npm as the underlying registry.
 
+## NAIDE vs Python — Side by Side
+
+**Read a file, process lines, write result:**
+
+```python
+# Python (8 lines)
+with open("input.txt") as f:
+    lines = f.read().strip().split("\n")
+upper_lines = [line.upper() for line in lines]
+result = "\n".join(upper_lines)
+with open("output.txt", "w") as f:
+    f.write(result)
+print(f"Processed {len(upper_lines)} lines")
+```
+
+```python
+# NAIDE (4 lines)
+list lines = split(trim(read("input.txt")), "\n")
+list upper_lines = [upper(line) for line in lines]
+write("output.txt", join(upper_lines, "\n"))
+print "Processed {len(upper_lines)} lines"
+```
+
+**Sort, deduplicate, and swap:**
+
+```python
+# Python (5 lines)
+items = [3, 1, 4, 1, 5]
+items = sorted(set(items))
+a, b = 1, 2
+a, b = b, a
+print(f"a={a}, b={b}")
+```
+
+```python
+# NAIDE (5 lines)
+list items = unique(sort([3, 1, 4, 1, 5]))
+mut int a = 1
+mut int b = 2
+swap a, b
+print "a={a}, b={b}"
+```
+
+**Simple API server:**
+
+```python
+# Python + Flask (12 lines)
+from flask import Flask, jsonify
+app = Flask(__name__)
+
+@app.route("/")
+def index():
+    return jsonify({"message": "Hello"})
+
+@app.route("/health")
+def health():
+    return jsonify({"status": "ok"})
+
+app.run(port=3000)
+```
+
+```python
+# NAIDE (5 lines)
+server app port 3000:
+  get "/":
+    ret {message: "Hello"}
+  get "/health":
+    ret {status: "ok"}
+```
+
 ## Why NAIDE?
 
 AI code generation speed depends on:
@@ -1412,6 +1482,7 @@ AI code generation speed depends on:
 1. **Token count** — fewer output tokens = faster generation
 2. **Predictability** — one way to write everything = better next-token prediction
 3. **Context window** — shorter code = more room for complex projects
+4. **Simplicity** — built-in functions mean zero imports and less boilerplate
 
 NAIDE-X is designed as an **AI-internal representation** — the AI thinks in NAIDE-X, users receive standard JavaScript.
 

package/bin/postinstall.js

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+
+import { execSync } from 'child_process';
+import { existsSync, writeFileSync, mkdirSync, readFileSync } from 'fs';
+import { resolve, dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const platform = process.platform;
+const naideBin = resolve(__dirname, 'naide.js');
+
+function run(cmd, opts = {}) {
+  try {
+    execSync(cmd, { stdio: 'pipe', ...opts });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function registerWindows() {
+  const nodePath = process.execPath;
+  const npmGlobal = resolve(dirname(nodePath), 'node_modules', 'naider', 'bin', 'naide.js');
+  const binPath = existsSync(npmGlobal) ? npmGlobal : naideBin;
+
+  const nodeEsc = nodePath.replace(/\\/g, '\\\\');
+  const binEsc = binPath.replace(/\\/g, '\\\\');
+  const cmd = `"${nodePath}" "${binPath}" "%1" %*`;
+
+  const regAdd = (key, value) => run(`reg add "${key}" /ve /d "${value}" /f`);
+
+  regAdd('HKCU\\Software\\Classes\\.naide', 'NAIDEFile');
+  regAdd('HKCU\\Software\\Classes\\.nx', 'NAIDEXFile');
+  regAdd('HKCU\\Software\\Classes\\NAIDEFile', 'NAIDE Source File');
+  regAdd('HKCU\\Software\\Classes\\NAIDEXFile', 'NAIDE-X Source File');
+  regAdd('HKCU\\Software\\Classes\\NAIDEFile\\shell\\open\\command', cmd);
+  regAdd('HKCU\\Software\\Classes\\NAIDEXFile\\shell\\open\\command', cmd);
+
+  run(`reg add "HKCU\\Software\\Classes\\NAIDEFile\\DefaultIcon" /ve /d "${nodeEsc},0" /f`);
+  run(`reg add "HKCU\\Software\\Classes\\NAIDEXFile\\DefaultIcon" /ve /d "${nodeEsc},0" /f`);
+
+  console.log('  .naide and .nx file associations registered (Windows)');
+}
+
+function registerMacOS() {
+  const plistDir = resolve(process.env.HOME, 'Library', 'LaunchAgents');
+  if (!existsSync(plistDir)) mkdirSync(plistDir, { recursive: true });
+
+  const handlerApp = resolve(process.env.HOME, '.naide', 'NAIDE.app');
+  const contentsDir = join(handlerApp, 'Contents');
+  const macosDir = join(contentsDir, 'MacOS');
+
+  mkdirSync(macosDir, { recursive: true });
+
+  writeFileSync(join(contentsDir, 'Info.plist'), `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>CFBundleName</key><string>NAIDE</string>
+  <key>CFBundleIdentifier</key><string>com.naide.runner</string>
+  <key>CFBundleVersion</key><string>1.0</string>
+  <key>CFBundleExecutable</key><string>naide-run</string>
+  <key>CFBundleDocumentTypes</key>
+  <array>
+    <dict>
+      <key>CFBundleTypeExtensions</key><array><string>naide</string><string>nx</string></array>
+      <key>CFBundleTypeName</key><string>NAIDE Source</string>
+      <key>CFBundleTypeRole</key><string>Editor</string>
+    </dict>
+  </array>
+</dict>
+</plist>`);
+
+  writeFileSync(join(macosDir, 'naide-run'), `#!/bin/bash\nexec node "${naideBin}" "$@"\n`);
+  run(`chmod +x "${join(macosDir, 'naide-run')}"`);
+
+  run(`/System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister -f "${handlerApp}"`);
+
+  console.log('  .naide and .nx file associations registered (macOS)');
+}
+
+function registerLinux() {
+  const mimeDir = resolve(process.env.HOME, '.local', 'share', 'mime', 'packages');
+  const appDir = resolve(process.env.HOME, '.local', 'share', 'applications');
+  mkdirSync(mimeDir, { recursive: true });
+  mkdirSync(appDir, { recursive: true });
+
+  writeFileSync(join(mimeDir, 'naide.xml'), `<?xml version="1.0" encoding="UTF-8"?>
+<mime-info xmlns="http://www.freedesktop.org/standards/shared-mime-info">
+  <mime-type type="text/x-naide">
+    <comment>NAIDE Source File</comment>
+    <glob pattern="*.naide"/>
+  </mime-type>
+  <mime-type type="text/x-naidex">
+    <comment>NAIDE-X Source File</comment>
+    <glob pattern="*.nx"/>
+  </mime-type>
+</mime-info>`);
+
+  writeFileSync(join(appDir, 'naide.desktop'), `[Desktop Entry]
+Type=Application
+Name=NAIDE
+Exec=node "${naideBin}" %f
+MimeType=text/x-naide;text/x-naidex;
+Terminal=true
+Categories=Development;
+`);
+
+  run('update-mime-database ~/.local/share/mime');
+  run('xdg-mime default naide.desktop text/x-naide');
+  run('xdg-mime default naide.desktop text/x-naidex');
+
+  console.log('  .naide and .nx file associations registered (Linux)');
+}
+
+console.log('NAIDE: Registering file extensions...');
+
+try {
+  if (platform === 'win32') {
+    registerWindows();
+  } else if (platform === 'darwin') {
+    registerMacOS();
+  } else {
+    registerLinux();
+  }
+} catch (e) {
+  console.log(`  Skipped file association (${e.message}). You can still run: naide <file.naide>`);
+}
+
+console.log('NAIDE: Installation complete! Run "naide --help" to get started.');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "naider",
-  "version": "1.16.0",
+  "version": "1.17.1",
   "description": "NAIDE - Simpler than Python, compiles to 15 targets. AI-specialized language with 35+ built-in functions, syntax sugar (unless/until/repeat/swap/is/isnt), and 47 features. Targets: Node.js, Python, TypeScript, C, C++, Java, Go, Rust, PHP, Ruby, Kotlin, Swift, Dart, C#, Bun.",
   "main": "src/index.js",
   "exports": {
@@ -25,7 +25,8 @@
   "scripts": {
     "test": "node --test test/test.js",
     "example": "node bin/naide.js examples/hello.naide",
-    "example:x": "node bin/naide.js examples/hello.nx"
+    "example:x": "node bin/naide.js examples/hello.nx",
+    "postinstall": "node bin/postinstall.js"
   },
   "keywords": [
     "ai",

package/src/generator-c.js

@@ -185,6 +185,8 @@ export class CGenerator {
       case 'GrpcDecl': return this.visitGrpc(node);
       case 'WebrtcDecl': return this.visitWebrtc(node);
       case 'BlockchainDecl': return this.visitBlockchain(node);
+      case 'EnumDecl': return this.visitEnum(node);
+      case 'Swap': return this.visitSwap(node);
       default:
         this.emit(`/* unknown: ${node.type} */`);
     }
@@ -873,6 +875,12 @@ export class CGenerator {
   generateCall(node) {
     const args = node.args.map(a => this.expr(a)).join(', ');
 
+    if (node.callee.type === 'Identifier') {
+      const argList = node.args.map(a => this.expr(a));
+      const b = this.generateBuiltin(node.callee.name, argList);
+      if (b) return b;
+    }
+
     if (node.callee.type === 'Identifier') {
       const name = node.callee.name;
       if (name === 'parseInt') return `atoi(${args})`;
@@ -974,6 +982,46 @@ export class CGenerator {
     return result;
   }
 
+  visitEnum(node) {
+    this.emit(`typedef enum {`);
+    this.indent++;
+    node.values.forEach((v, i) => {
+      this.emit(`${node.name}_${v} = ${i},`);
+    });
+    this.indent--;
+    this.emit(`} ${node.name};`);
+    this.emitRaw('');
+  }
+
+  visitSwap(node) {
+    const a = this.expr(node.a);
+    const b = this.expr(node.b);
+    const tmp = `_tmp_${a.replace(/[^a-zA-Z0-9]/g, '')}`;
+    this.emit(`{ typeof(${a}) ${tmp} = ${a}; ${a} = ${b}; ${b} = ${tmp}; }`);
+  }
+
+  generateBuiltin(name, args) {
+    switch (name) {
+      case 'len': return `(sizeof(${args[0]}) / sizeof(${args[0]}[0]))`;
+      case 'abs': return `abs(${args[0]})`;
+      case 'sqrt': { this.includes.add('<math.h>'); return `sqrt(${args[0]})`; }
+      case 'pow': { this.includes.add('<math.h>'); return `pow(${args[0]}, ${args[1]})`; }
+      case 'ceil': { this.includes.add('<math.h>'); return `ceil(${args[0]})`; }
+      case 'floor': { this.includes.add('<math.h>'); return `floor(${args[0]})`; }
+      case 'round': { this.includes.add('<math.h>'); return `round(${args[0]})`; }
+      case 'exit': { this.includes.add('<stdlib.h>'); return `exit(${args[0] || '0'})`; }
+      case 'str': return `snprintf(_buf, sizeof(_buf), "%d", ${args[0]})`;
+      case 'int': { this.includes.add('<stdlib.h>'); return `atoi(${args[0]})`; }
+      case 'float': { this.includes.add('<stdlib.h>'); return `atof(${args[0]})`; }
+      case 'upper': { this.includes.add('<ctype.h>'); return `toupper(${args[0]})`; }
+      case 'lower': { this.includes.add('<ctype.h>'); return `tolower(${args[0]})`; }
+      case 'sleep': { this.includes.add('<unistd.h>'); return `usleep(${args[0]} * 1000)`; }
+      case 'now': { this.includes.add('<time.h>'); return `(long long)time(NULL) * 1000`; }
+      case 'random': { this.includes.add('<stdlib.h>'); return args.length >= 2 ? `(rand() % (${args[1]} - ${args[0]} + 1) + ${args[0]})` : `rand()`; }
+      default: return null;
+    }
+  }
+
   rawString(strData) {
     if (!strData) return '';
     if (strData.raw !== null && strData.raw !== undefined) return strData.raw;

package/src/generator-cpp.js

@@ -186,6 +186,8 @@ export class CppGenerator {
       case 'GrpcDecl': return this.visitGrpc(node);
       case 'WebrtcDecl': return this.visitWebrtc(node);
       case 'BlockchainDecl': return this.visitBlockchain(node);
+      case 'EnumDecl': return this.visitEnum(node);
+      case 'Swap': return this.visitSwap(node);
       default:
         this.emit(`/* unknown: ${node.type} */`);
     }
@@ -983,6 +985,10 @@ export class CppGenerator {
     const args = node.args.map(a => this.expr(a)).join(', ');
 
     if (node.callee.type === 'Identifier') {
+      const argList = node.args.map(a => this.expr(a));
+      const b = this.generateBuiltin(node.callee.name, argList);
+      if (b) return b;
+
       const name = node.callee.name;
       if (name === 'parseInt') return `stoi(${args})`;
       if (name === 'parseFloat') return `stod(${args})`;
@@ -1208,4 +1214,51 @@ export class CppGenerator {
     this.inFunction = saved;
     return result;
   }
+
+  visitEnum(node) {
+    this.emit(`enum class ${node.name} {`);
+    this.indent++;
+    node.values.forEach((v, i) => {
+      this.emit(`${v} = ${i},`);
+    });
+    this.indent--;
+    this.emit(`};`);
+    this.emitRaw('');
+  }
+
+  visitSwap(node) {
+    this.includes.add('<utility>');
+    const a = this.expr(node.a);
+    const b = this.expr(node.b);
+    this.emit(`std::swap(${a}, ${b});`);
+  }
+
+  generateBuiltin(name, args) {
+    switch (name) {
+      case 'len': return `${args[0]}.size()`;
+      case 'sort': { this.includes.add('<algorithm>'); return `([&](){ auto _v = ${args[0]}; std::sort(_v.begin(), _v.end()); return _v; }())`; }
+      case 'reverse': { this.includes.add('<algorithm>'); return `([&](){ auto _v = ${args[0]}; std::reverse(_v.begin(), _v.end()); return _v; }())`; }
+      case 'contains': return `(std::find(${args[0]}.begin(), ${args[0]}.end(), ${args[1]}) != ${args[0]}.end())`;
+      case 'abs': { this.includes.add('<cmath>'); return `std::abs(${args[0]})`; }
+      case 'sqrt': { this.includes.add('<cmath>'); return `std::sqrt(${args[0]})`; }
+      case 'pow': { this.includes.add('<cmath>'); return `std::pow(${args[0]}, ${args[1]})`; }
+      case 'ceil': { this.includes.add('<cmath>'); return `std::ceil(${args[0]})`; }
+      case 'floor': { this.includes.add('<cmath>'); return `std::floor(${args[0]})`; }
+      case 'round': { this.includes.add('<cmath>'); return `std::round(${args[0]})`; }
+      case 'str': return `std::to_string(${args[0]})`;
+      case 'int': return `std::stoi(${args[0]})`;
+      case 'float': return `std::stof(${args[0]})`;
+      case 'upper': { this.includes.add('<algorithm>'); this.includes.add('<cctype>'); return `([&](){ auto _s = ${args[0]}; std::transform(_s.begin(), _s.end(), _s.begin(), ::toupper); return _s; }())`; }
+      case 'lower': { this.includes.add('<algorithm>'); this.includes.add('<cctype>'); return `([&](){ auto _s = ${args[0]}; std::transform(_s.begin(), _s.end(), _s.begin(), ::tolower); return _s; }())`; }
+      case 'trim': return `([&](){ auto _s = ${args[0]}; _s.erase(0, _s.find_first_not_of(" \\t\\n\\r")); _s.erase(_s.find_last_not_of(" \\t\\n\\r") + 1); return _s; }())`;
+      case 'keys': return `([&](){ std::vector<std::string> _k; for (auto& [k,v] : ${args[0]}) _k.push_back(k); return _k; }())`;
+      case 'values': return `([&](){ std::vector<auto> _v; for (auto& [k,v] : ${args[0]}) _v.push_back(v); return _v; }())`;
+      case 'exit': return `exit(${args[0] || '0'})`;
+      case 'sleep': { this.includes.add('<thread>'); this.includes.add('<chrono>'); return `std::this_thread::sleep_for(std::chrono::milliseconds(${args[0]}))`; }
+      case 'now': { this.includes.add('<chrono>'); return `std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count()`; }
+      case 'random': { this.includes.add('<random>'); return args.length >= 2 ? `([](int a, int b){ std::random_device rd; std::mt19937 gen(rd()); std::uniform_int_distribution<> dis(a,b); return dis(gen); })(${args[0]}, ${args[1]})` : `([]{ std::random_device rd; return rd(); }())`; }
+      case 'sum': return `([&](){ auto _v = ${args[0]}; return std::accumulate(_v.begin(), _v.end(), 0); }())`;
+      default: return null;
+    }
+  }
 }

package/src/generator-csharp.js

@@ -178,6 +178,8 @@ export class CSharpGenerator {
       case 'GrpcDecl': return this.visitGrpc(node);
       case 'WebrtcDecl': return this.visitWebrtc(node);
       case 'BlockchainDecl': return this.visitBlockchain(node);
+      case 'EnumDecl': return this.visitEnum(node);
+      case 'Swap': return this.visitSwap(node);
       default:
         this.emit(`// unknown: ${node.type}`);
     }
@@ -1431,6 +1433,12 @@ export class CSharpGenerator {
   generateCall(node) {
     const args = node.args.map(a => this.expr(a)).join(', ');
 
+    if (node.callee.type === 'Identifier') {
+      const argList = node.args.map(a => this.expr(a));
+      const b = this.generateBuiltin(node.callee.name, argList);
+      if (b) return b;
+    }
+
     if (node.callee.type === 'Identifier') {
       const name = node.callee.name;
       if (name === 'parseInt') return `int.Parse(${args})`;
@@ -1630,4 +1638,63 @@ export class CSharpGenerator {
     this.indent = savedIndent;
     return result;
   }
+
+  visitEnum(node) {
+    this.emit(`enum ${node.name} {`);
+    this.indent++;
+    this.emit(node.values.join(', '));
+    this.indent--;
+    this.emit(`}`);
+    this.emitRaw('');
+  }
+
+  visitSwap(node) {
+    const a = this.expr(node.a);
+    const b = this.expr(node.b);
+    this.emit(`(${a}, ${b}) = (${b}, ${a});`);
+  }
+
+  generateBuiltin(name, args) {
+    switch (name) {
+      case 'len': return `${args[0]}.Count`;
+      case 'sort': return `${args[0]}.OrderBy(x => x).ToList()`;
+      case 'reverse': return `${args[0]}.AsEnumerable().Reverse().ToList()`;
+      case 'unique': return `${args[0]}.Distinct().ToList()`;
+      case 'upper': return `${args[0]}.ToUpper()`;
+      case 'lower': return `${args[0]}.ToLower()`;
+      case 'trim': return `${args[0]}.Trim()`;
+      case 'split': return `${args[0]}.Split(${args[1] || '","'}).ToList()`;
+      case 'join': return `string.Join(${args[1] || '","'}, ${args[0]})`;
+      case 'contains': return `${args[0]}.Contains(${args[1]})`;
+      case 'replace': return `${args[0]}.Replace(${args[1]}, ${args[2]})`;
+      case 'keys': return `${args[0]}.Keys.ToList()`;
+      case 'values': return `${args[0]}.Values.ToList()`;
+      case 'entries': return `${args[0]}.ToList()`;
+      case 'range': return args.length >= 2 ? `Enumerable.Range(${args[0]}, ${args[1]} - ${args[0]}).ToList()` : `Enumerable.Range(0, ${args[0]}).ToList()`;
+      case 'abs': return `Math.Abs(${args[0]})`;
+      case 'sqrt': return `Math.Sqrt(${args[0]})`;
+      case 'pow': return `Math.Pow(${args[0]}, ${args[1]})`;
+      case 'ceil': return `Math.Ceiling((double)${args[0]})`;
+      case 'floor': return `Math.Floor((double)${args[0]})`;
+      case 'round': return `Math.Round((double)${args[0]})`;
+      case 'sum': return `${args[0]}.Sum()`;
+      case 'flat': return `${args[0]}.SelectMany(x => x).ToList()`;
+      case 'zip': return `${args[0]}.Zip(${args[1]}).ToList()`;
+      case 'chunk': return `${args[0]}.Chunk(${args[1]}).Select(c => c.ToList()).ToList()`;
+      case 'str': return `${args[0]}.ToString()`;
+      case 'int': return `int.Parse(${args[0]})`;
+      case 'float': return `double.Parse(${args[0]})`;
+      case 'json_parse': return `System.Text.Json.JsonSerializer.Deserialize<object>(${args[0]})`;
+      case 'json_str': return `System.Text.Json.JsonSerializer.Serialize(${args[0]})`;
+      case 'now': return `DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()`;
+      case 'time': return `DateTime.Now.ToString("o")`;
+      case 'exit': return `Environment.Exit(${args[0] || '0'})`;
+      case 'sleep': return `Thread.Sleep(${args[0]})`;
+      case 'random': return args.length >= 2 ? `new Random().Next(${args[0]}, ${args[1]} + 1)` : `new Random().NextDouble()`;
+      case 'read': return `File.ReadAllText(${args[0]})`;
+      case 'write': return `File.WriteAllText(${args[0]}, ${args[1]})`;
+      case 'ask': return `(Console.Write(${args[0] || '""'}), Console.ReadLine() ?? "").Item2`;
+      default: return null;
+    }
+  }
 }

package/src/generator-dart.js

@@ -162,6 +162,8 @@ export class DartGenerator {
       case 'GrpcDecl': return this.visitGrpc(node);
       case 'WebrtcDecl': return this.visitWebrtc(node);
       case 'BlockchainDecl': return this.visitBlockchain(node);
+      case 'EnumDecl': return this.visitEnum(node);
+      case 'Swap': return this.visitSwap(node);
       default:
         this.emit(`// unknown: ${node.type}`);
     }
@@ -1364,6 +1366,12 @@ export class DartGenerator {
   generateCall(node) {
     const args = node.args.map(a => this.expr(a)).join(', ');
 
+    if (node.callee.type === 'Identifier') {
+      const argList = node.args.map(a => this.expr(a));
+      const b = this.generateBuiltin(node.callee.name, argList);
+      if (b) return b;
+    }
+
     if (node.callee.type === 'Identifier') {
       const name = node.callee.name;
       if (name === 'parseInt') return `int.parse(${args})`;
@@ -1566,4 +1574,65 @@ export class DartGenerator {
     this.inFunction = wasInFunction;
     return result;
   }
+
+  visitEnum(node) {
+    this.emit(`enum ${node.name} {`);
+    this.indent++;
+    node.values.forEach(v => {
+      this.emit(`${v.toLowerCase()},`);
+    });
+    this.indent--;
+    this.emit(`}`);
+    this.emitRaw('');
+  }
+
+  visitSwap(node) {
+    const a = this.expr(node.a);
+    const b = this.expr(node.b);
+    this.emit(`{ final _tmp = ${a}; ${a} = ${b}; ${b} = _tmp; }`);
+  }
+
+  generateBuiltin(name, args) {
+    switch (name) {
+      case 'len': return `${args[0]}.length`;
+      case 'sort': return `(List.from(${args[0]})..sort())`;
+      case 'reverse': return `${args[0]}.reversed.toList()`;
+      case 'unique': return `${args[0]}.toSet().toList()`;
+      case 'upper': return `${args[0]}.toUpperCase()`;
+      case 'lower': return `${args[0]}.toLowerCase()`;
+      case 'trim': return `${args[0]}.trim()`;
+      case 'split': return `${args[0]}.split(${args[1] || '","'})`;
+      case 'join': return `${args[0]}.join(${args[1] || '","'})`;
+      case 'contains': return `${args[0]}.contains(${args[1]})`;
+      case 'replace': return `${args[0]}.replaceAll(${args[1]}, ${args[2]})`;
+      case 'keys': return `${args[0]}.keys.toList()`;
+      case 'values': return `${args[0]}.values.toList()`;
+      case 'entries': return `${args[0]}.entries.toList()`;
+      case 'range': return args.length >= 2 ? `List.generate(${args[1]} - ${args[0]}, (i) => i + ${args[0]})` : `List.generate(${args[0]}, (i) => i)`;
+      case 'abs': return `${args[0]}.abs()`;
+      case 'sqrt': { this.addImport('dart:math'); return `sqrt(${args[0]}.toDouble())`; }
+      case 'pow': { this.addImport('dart:math'); return `pow(${args[0]}, ${args[1]})`; }
+      case 'ceil': return `${args[0]}.ceil()`;
+      case 'floor': return `${args[0]}.floor()`;
+      case 'round': return `${args[0]}.round()`;
+      case 'sum': return `${args[0]}.reduce((a, b) => a + b)`;
+      case 'flat': return `${args[0]}.expand((x) => x).toList()`;
+      case 'zip': return `List.generate(${args[0]}.length, (i) => [${args[0]}[i], ${args[1]}[i]])`;
+      case 'chunk': return `[for (var i = 0; i < ${args[0]}.length; i += ${args[1]}) ${args[0]}.sublist(i, i + ${args[1]} > ${args[0]}.length ? ${args[0]}.length : i + ${args[1]})]`;
+      case 'str': return `${args[0]}.toString()`;
+      case 'int': return `int.parse(${args[0]})`;
+      case 'float': return `double.parse(${args[0]})`;
+      case 'json_parse': { this.addImport('dart:convert'); return `jsonDecode(${args[0]})`; }
+      case 'json_str': { this.addImport('dart:convert'); return `jsonEncode(${args[0]})`; }
+      case 'now': return `DateTime.now().millisecondsSinceEpoch`;
+      case 'time': return `DateTime.now().toIso8601String()`;
+      case 'exit': return `exit(${args[0] || '0'})`;
+      case 'sleep': return `await Future.delayed(Duration(milliseconds: ${args[0]}))`;
+      case 'random': { this.addImport('dart:math'); return args.length >= 2 ? `(Random().nextInt(${args[1]} - ${args[0]} + 1) + ${args[0]})` : `Random().nextDouble()`; }
+      case 'read': { this.addImport('dart:io'); return `File(${args[0]}).readAsStringSync()`; }
+      case 'write': { this.addImport('dart:io'); return `File(${args[0]}).writeAsStringSync(${args[1]})`; }
+      case 'ask': { this.addImport('dart:io'); return `((){stdout.write(${args[0] || '""'}); return stdin.readLineSync() ?? "";}())`; }
+      default: return null;
+    }
+  }
 }

package/src/generator-go.js

@@ -116,6 +116,8 @@ export class GoGenerator {
       case 'GrpcDecl': return this.visitGrpc(node);
       case 'WebrtcDecl': return this.visitWebrtc(node);
       case 'BlockchainDecl': return this.visitBlockchain(node);
+      case 'EnumDecl': return this.visitEnum(node);
+      case 'Swap': return this.visitSwap(node);
       default:
         this.emit(`// unknown: ${node.type}`);
     }
@@ -1614,6 +1616,12 @@ export class GoGenerator {
   }
 
   generateCall(node) {
+    if (node.callee.type === 'Identifier') {
+      const argList = node.args.map(a => this.expr(a));
+      const b = this.generateBuiltin(node.callee.name, argList);
+      if (b) return b;
+    }
+
     const args = node.args.map(a => this.expr(a)).join(', ');
 
     // Map common JS global functions to Go
@@ -1778,4 +1786,58 @@ export class GoGenerator {
     this.indent = savedIndent;
     return result;
   }
+
+  visitEnum(node) {
+    this.emit(`type ${node.name} int`);
+    this.emit(`const (`);
+    this.indent++;
+    node.values.forEach((v, i) => {
+      if (i === 0) {
+        this.emit(`${v} ${node.name} = iota`);
+      } else {
+        this.emit(`${v}`);
+      }
+    });
+    this.indent--;
+    this.emit(`)`);
+    this.emitRaw('');
+  }
+
+  visitSwap(node) {
+    const a = this.expr(node.a);
+    const b = this.expr(node.b);
+    this.emit(`${a}, ${b} = ${b}, ${a}`);
+  }
+
+  generateBuiltin(name, args) {
+    switch (name) {
+      case 'len': return `len(${args[0]})`;
+      case 'str': { this.addImport('strconv'); return `strconv.Itoa(${args[0]})`; }
+      case 'int': { this.addImport('strconv'); return `func() int { v, _ := strconv.Atoi(${args[0]}); return v }()`; }
+      case 'float': { this.addImport('strconv'); return `func() float64 { v, _ := strconv.ParseFloat(${args[0]}, 64); return v }()`; }
+      case 'upper': { this.addImport('strings'); return `strings.ToUpper(${args[0]})`; }
+      case 'lower': { this.addImport('strings'); return `strings.ToLower(${args[0]})`; }
+      case 'trim': { this.addImport('strings'); return `strings.TrimSpace(${args[0]})`; }
+      case 'split': { this.addImport('strings'); return `strings.Split(${args[0]}, ${args[1] || '","'})`; }
+      case 'join': { this.addImport('strings'); return `strings.Join(${args[0]}, ${args[1] || '","'})`; }
+      case 'contains': { this.addImport('strings'); return `strings.Contains(${args[0]}, ${args[1]})`; }
+      case 'replace': { this.addImport('strings'); return `strings.ReplaceAll(${args[0]}, ${args[1]}, ${args[2]})`; }
+      case 'abs': { this.addImport('math'); return `math.Abs(${args[0]})`; }
+      case 'sqrt': { this.addImport('math'); return `math.Sqrt(${args[0]})`; }
+      case 'pow': { this.addImport('math'); return `math.Pow(${args[0]}, ${args[1]})`; }
+      case 'ceil': { this.addImport('math'); return `math.Ceil(${args[0]})`; }
+      case 'floor': { this.addImport('math'); return `math.Floor(${args[0]})`; }
+      case 'round': { this.addImport('math'); return `math.Round(${args[0]})`; }
+      case 'exit': { this.addImport('os'); return `os.Exit(${args[0] || '0'})`; }
+      case 'sleep': { this.addImport('time'); return `time.Sleep(time.Duration(${args[0]}) * time.Millisecond)`; }
+      case 'now': { this.addImport('time'); return `time.Now().UnixMilli()`; }
+      case 'time': { this.addImport('time'); return `time.Now().Format(time.RFC3339)`; }
+      case 'json_parse': { this.addImport('encoding/json'); return `func() interface{} { var v interface{}; json.Unmarshal([]byte(${args[0]}), &v); return v }()`; }
+      case 'json_str': { this.addImport('encoding/json'); return `func() string { b, _ := json.Marshal(${args[0]}); return string(b) }()`; }
+      case 'random': { this.addImport('math/rand'); return args.length >= 2 ? `rand.Intn(${args[1]}-${args[0]}+1)+${args[0]}` : `rand.Float64()`; }
+      case 'sort': { this.addImport('sort'); return `func() []int { s := make([]int, len(${args[0]})); copy(s, ${args[0]}); sort.Ints(s); return s }()`; }
+      case 'reverse': return `func() []interface{} { s := make([]interface{}, len(${args[0]})); copy(s, ${args[0]}); for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 { s[i], s[j] = s[j], s[i] }; return s }()`;
+      default: return null;
+    }
+  }
 }

package/src/generator-java.js

@@ -226,6 +226,8 @@ export class JavaGenerator {
       case 'GrpcDecl': return this.visitGrpc(node);
       case 'WebrtcDecl': return this.visitWebrtc(node);
       case 'BlockchainDecl': return this.visitBlockchain(node);
+      case 'EnumDecl': return this.visitEnum(node);
+      case 'Swap': return this.visitSwap(node);
       default:
         this.emit(`/* unknown: ${node.type} */`);
     }
@@ -1598,6 +1600,12 @@ export class JavaGenerator {
   }
 
   generateCall(node) {
+    if (node.callee.type === 'Identifier') {
+      const argList = node.args.map(a => this.expr(a));
+      const b = this.generateBuiltin(node.callee.name, argList);
+      if (b) return b;
+    }
+
     const args = node.args.map(a => this.expr(a)).join(', ');
 
     if (node.callee.type === 'Identifier') {
@@ -1811,4 +1819,57 @@ export class JavaGenerator {
     this.indent = savedIndent;
     return result;
   }
+
+  visitEnum(node) {
+    this.emit(`enum ${node.name} {`);
+    this.indent++;
+    this.emit(node.values.join(', ') + ';');
+    this.indent--;
+    this.emit(`}`);
+    this.emitRaw('');
+  }
+
+  visitSwap(node) {
+    const a = this.expr(node.a);
+    const b = this.expr(node.b);
+    this.emit(`{ var _tmp = ${a}; ${a} = ${b}; ${b} = _tmp; }`);
+  }
+
+  generateBuiltin(name, args) {
+    switch (name) {
+      case 'len': return `${args[0]}.size()`;
+      case 'sort': return `${args[0]}.stream().sorted().collect(java.util.stream.Collectors.toList())`;
+      case 'reverse': return `{ var _l = new java.util.ArrayList<>(${args[0]}); java.util.Collections.reverse(_l); return _l; }`;
+      case 'contains': return `${args[0]}.contains(${args[1]})`;
+      case 'keys': return `new java.util.ArrayList<>(${args[0]}.keySet())`;
+      case 'values': return `new java.util.ArrayList<>(${args[0]}.values())`;
+      case 'entries': return `new java.util.ArrayList<>(${args[0]}.entrySet())`;
+      case 'abs': return `Math.abs(${args[0]})`;
+      case 'sqrt': return `Math.sqrt(${args[0]})`;
+      case 'pow': return `Math.pow(${args[0]}, ${args[1]})`;
+      case 'ceil': return `Math.ceil(${args[0]})`;
+      case 'floor': return `Math.floor(${args[0]})`;
+      case 'round': return `Math.round(${args[0]})`;
+      case 'random': return args.length >= 2 ? `new java.util.Random().nextInt(${args[1]} - ${args[0]} + 1) + ${args[0]}` : `Math.random()`;
+      case 'str': return `String.valueOf(${args[0]})`;
+      case 'int': return `Integer.parseInt(${args[0]})`;
+      case 'float': return `Double.parseDouble(${args[0]})`;
+      case 'upper': return `${args[0]}.toUpperCase()`;
+      case 'lower': return `${args[0]}.toLowerCase()`;
+      case 'trim': return `${args[0]}.trim()`;
+      case 'split': return `java.util.Arrays.asList(${args[0]}.split(${args[1] || '","'}))`;
+      case 'join': return `String.join(${args[1] || '","'}, ${args[0]})`;
+      case 'replace': return `${args[0]}.replace(${args[1]}, ${args[2]})`;
+      case 'sum': return `${args[0]}.stream().mapToInt(Integer::intValue).sum()`;
+      case 'unique': return `new java.util.ArrayList<>(new java.util.LinkedHashSet<>(${args[0]}))`;
+      case 'exit': return `System.exit(${args[0] || '0'})`;
+      case 'sleep': return `Thread.sleep(${args[0]})`;
+      case 'now': return `System.currentTimeMillis()`;
+      case 'time': return `java.time.LocalDateTime.now().toString()`;
+      case 'json_parse': return `new com.google.gson.Gson().fromJson(${args[0]}, Object.class)`;
+      case 'json_str': return `new com.google.gson.Gson().toJson(${args[0]})`;
+      case 'range': return args.length >= 2 ? `java.util.stream.IntStream.range(${args[0]}, ${args[1]}).boxed().collect(java.util.stream.Collectors.toList())` : `java.util.stream.IntStream.range(0, ${args[0]}).boxed().collect(java.util.stream.Collectors.toList())`;
+      default: return null;
+    }
+  }
 }

package/src/generator-kotlin.js

@@ -137,6 +137,8 @@ export class KotlinGenerator {
       case 'GrpcDecl': return this.visitGrpc(node);
       case 'WebrtcDecl': return this.visitWebrtc(node);
       case 'BlockchainDecl': return this.visitBlockchain(node);
+      case 'EnumDecl': return this.visitEnum(node);
+      case 'Swap': return this.visitSwap(node);
       default:
         this.emit(`// unknown: ${node.type}`);
     }
@@ -1641,6 +1643,12 @@ export class KotlinGenerator {
   generateCall(node) {
     const args = node.args.map(a => this.expr(a)).join(', ');
 
+    if (node.callee.type === 'Identifier') {
+      const argList = node.args.map(a => this.expr(a));
+      const b = this.generateBuiltin(node.callee.name, argList);
+      if (b) return b;
+    }
+
     if (node.callee.type === 'Identifier') {
       const name = node.callee.name;
       if (name === 'parseInt') return `(${args}).toInt()`;
@@ -1816,4 +1824,63 @@ export class KotlinGenerator {
     this.indent = savedIndent;
     return result;
   }
+
+  visitEnum(node) {
+    this.emit(`enum class ${node.name} {`);
+    this.indent++;
+    this.emit(node.values.join(', '));
+    this.indent--;
+    this.emit(`}`);
+    this.emitRaw('');
+  }
+
+  visitSwap(node) {
+    const a = this.expr(node.a);
+    const b = this.expr(node.b);
+    this.emit(`${a} = ${b}.also { ${b} = ${a} }`);
+  }
+
+  generateBuiltin(name, args) {
+    switch (name) {
+      case 'len': return `${args[0]}.size`;
+      case 'sort': return `${args[0]}.sorted()`;
+      case 'reverse': return `${args[0]}.reversed()`;
+      case 'unique': return `${args[0]}.distinct()`;
+      case 'upper': return `${args[0]}.uppercase()`;
+      case 'lower': return `${args[0]}.lowercase()`;
+      case 'trim': return `${args[0]}.trim()`;
+      case 'split': return `${args[0]}.split(${args[1] || '","'})`;
+      case 'join': return `${args[0]}.joinToString(${args[1] || '","'})`;
+      case 'contains': return `${args[0]}.contains(${args[1]})`;
+      case 'replace': return `${args[0]}.replace(${args[1]}, ${args[2]})`;
+      case 'keys': return `${args[0]}.keys.toList()`;
+      case 'values': return `${args[0]}.values.toList()`;
+      case 'entries': return `${args[0]}.entries.toList()`;
+      case 'range': return args.length >= 2 ? `(${args[0]} until ${args[1]}).toList()` : `(0 until ${args[0]}).toList()`;
+      case 'abs': return `kotlin.math.abs(${args[0]})`;
+      case 'sqrt': return `kotlin.math.sqrt(${args[0]}.toDouble())`;
+      case 'pow': return `kotlin.math.pow(${args[0]}.toDouble(), ${args[1]}.toDouble())`;
+      case 'ceil': return `kotlin.math.ceil(${args[0]}.toDouble())`;
+      case 'floor': return `kotlin.math.floor(${args[0]}.toDouble())`;
+      case 'round': return `kotlin.math.round(${args[0]}.toDouble())`;
+      case 'sum': return `${args[0]}.sum()`;
+      case 'flat': return `${args[0]}.flatten()`;
+      case 'zip': return `${args[0]}.zip(${args[1]})`;
+      case 'chunk': return `${args[0]}.chunked(${args[1]})`;
+      case 'str': return `${args[0]}.toString()`;
+      case 'int': return `${args[0]}.toInt()`;
+      case 'float': return `${args[0]}.toDouble()`;
+      case 'json_parse': return `com.google.gson.Gson().fromJson(${args[0]}, Any::class.java)`;
+      case 'json_str': return `com.google.gson.Gson().toJson(${args[0]})`;
+      case 'now': return `System.currentTimeMillis()`;
+      case 'time': return `java.time.LocalDateTime.now().toString()`;
+      case 'exit': return `kotlin.system.exitProcess(${args[0] || '0'})`;
+      case 'sleep': return `Thread.sleep(${args[0]}.toLong())`;
+      case 'random': return args.length >= 2 ? `(${args[0]}..${args[1]}).random()` : `kotlin.random.Random.nextDouble()`;
+      case 'read': return `java.io.File(${args[0]}).readText()`;
+      case 'write': return `java.io.File(${args[0]}).writeText(${args[1]})`;
+      case 'ask': return `(print(${args[0] || '""'}); readLine() ?: "")`;
+      default: return null;
+    }
+  }
 }

package/src/generator-php.js

@@ -103,6 +103,8 @@ export class PhpGenerator {
       case 'GrpcDecl': return this.visitGrpc(node);
       case 'WebrtcDecl': return this.visitWebrtc(node);
       case 'BlockchainDecl': return this.visitBlockchain(node);
+      case 'EnumDecl': return this.visitEnum(node);
+      case 'Swap': return this.visitSwap(node);
       default:
         this.emit(`/* unknown: ${node.type} */`);
     }
@@ -1366,6 +1368,12 @@ export class PhpGenerator {
   }
 
   generateCall(node) {
+    if (node.callee.type === 'Identifier') {
+      const argList = node.args.map(a => this.expr(a));
+      const b = this.generateBuiltin(node.callee.name, argList);
+      if (b) return b;
+    }
+
     const args = node.args.map(a => this.expr(a)).join(', ');
 
     // Map global function calls
@@ -1573,4 +1581,65 @@ export class PhpGenerator {
     this.indent = savedIndent;
     return result;
   }
+
+  visitEnum(node) {
+    this.emit(`class ${node.name} {`);
+    this.indent++;
+    node.values.forEach((v, i) => {
+      this.emit(`const ${v} = ${i};`);
+    });
+    this.indent--;
+    this.emit(`}`);
+    this.emitRaw('');
+  }
+
+  visitSwap(node) {
+    const a = this.expr(node.a);
+    const b = this.expr(node.b);
+    this.emit(`[$${a.replace('$','')}, $${b.replace('$','')}] = [$${b.replace('$','')}, $${a.replace('$','')}];`);
+  }
+
+  generateBuiltin(name, args) {
+    switch (name) {
+      case 'len': return `count(${args[0]})`;
+      case 'sort': return `(function($a) { sort($a); return $a; })(${args[0]})`;
+      case 'reverse': return `array_reverse(${args[0]})`;
+      case 'unique': return `array_values(array_unique(${args[0]}))`;
+      case 'upper': return `strtoupper(${args[0]})`;
+      case 'lower': return `strtolower(${args[0]})`;
+      case 'trim': return `trim(${args[0]})`;
+      case 'split': return `explode(${args[1] || '","'}, ${args[0]})`;
+      case 'join': return `implode(${args[1] || '","'}, ${args[0]})`;
+      case 'contains': return `in_array(${args[1]}, ${args[0]})`;
+      case 'replace': return `str_replace(${args[1]}, ${args[2]}, ${args[0]})`;
+      case 'keys': return `array_keys(${args[0]})`;
+      case 'values': return `array_values(${args[0]})`;
+      case 'entries': return `array_map(null, array_keys(${args[0]}), array_values(${args[0]}))`;
+      case 'range': return args.length >= 2 ? `range(${args[0]}, ${args[1]} - 1)` : `range(0, ${args[0]} - 1)`;
+      case 'abs': return `abs(${args[0]})`;
+      case 'round': return `round(${args[0]})`;
+      case 'ceil': return `ceil(${args[0]})`;
+      case 'floor': return `floor(${args[0]})`;
+      case 'sqrt': return `sqrt(${args[0]})`;
+      case 'pow': return `pow(${args[0]}, ${args[1]})`;
+      case 'sum': return `array_sum(${args[0]})`;
+      case 'flat': return `array_merge(...${args[0]})`;
+      case 'str': return `strval(${args[0]})`;
+      case 'int': return `intval(${args[0]})`;
+      case 'float': return `floatval(${args[0]})`;
+      case 'json_parse': return `json_decode(${args[0]}, true)`;
+      case 'json_str': return `json_encode(${args[0]})`;
+      case 'now': return `(int)(microtime(true) * 1000)`;
+      case 'time': return `date('c')`;
+      case 'exit': return `exit(${args[0] || '0'})`;
+      case 'sleep': return `usleep(${args[0]} * 1000)`;
+      case 'random': return args.length >= 2 ? `random_int(${args[0]}, ${args[1]})` : `(mt_rand() / mt_getrandmax())`;
+      case 'read': return `file_get_contents(${args[0]})`;
+      case 'write': return `file_put_contents(${args[0]}, ${args[1]})`;
+      case 'ask': return `readline(${args[0] || '""'})`;
+      case 'chunk': return `array_chunk(${args[0]}, ${args[1]})`;
+      case 'zip': return `array_map(null, ${args[0]}, ${args[1]})`;
+      default: return null;
+    }
+  }
 }

package/src/generator-ruby.js

@@ -111,6 +111,8 @@ export class RubyGenerator {
       case 'GrpcDecl': return this.visitGrpc(node);
       case 'WebrtcDecl': return this.visitWebrtc(node);
       case 'BlockchainDecl': return this.visitBlockchain(node);
+      case 'EnumDecl': return this.visitEnum(node);
+      case 'Swap': return this.visitSwap(node);
       default:
         this.emit(`# unknown: ${node.type}`);
     }
@@ -1330,6 +1332,12 @@ export class RubyGenerator {
   }
 
   generateCall(node) {
+    if (node.callee.type === 'Identifier') {
+      const argList = node.args.map(a => this.expr(a));
+      const b = this.generateBuiltin(node.callee.name, argList);
+      if (b) return b;
+    }
+
     const args = node.args.map(a => this.expr(a)).join(', ');
 
     // Map global function calls
@@ -1527,4 +1535,65 @@ export class RubyGenerator {
     this.indent = savedIndent;
     return result;
   }
+
+  visitEnum(node) {
+    this.emit(`module ${node.name}`);
+    this.indent++;
+    node.values.forEach((v, i) => {
+      this.emit(`${v} = ${i}`);
+    });
+    this.indent--;
+    this.emit(`end`);
+    this.emitRaw('');
+  }
+
+  visitSwap(node) {
+    const a = this.expr(node.a);
+    const b = this.expr(node.b);
+    this.emit(`${a}, ${b} = ${b}, ${a}`);
+  }
+
+  generateBuiltin(name, args) {
+    switch (name) {
+      case 'len': return `${args[0]}.length`;
+      case 'sort': return `${args[0]}.sort`;
+      case 'reverse': return `${args[0]}.reverse`;
+      case 'unique': return `${args[0]}.uniq`;
+      case 'upper': return `${args[0]}.upcase`;
+      case 'lower': return `${args[0]}.downcase`;
+      case 'trim': return `${args[0]}.strip`;
+      case 'split': return `${args[0]}.split(${args[1] || '","'})`;
+      case 'join': return `${args[0]}.join(${args[1] || '","'})`;
+      case 'contains': return `${args[0]}.include?(${args[1]})`;
+      case 'replace': return `${args[0]}.gsub(${args[1]}, ${args[2]})`;
+      case 'keys': return `${args[0]}.keys`;
+      case 'values': return `${args[0]}.values`;
+      case 'entries': return `${args[0]}.to_a`;
+      case 'range': return args.length >= 2 ? `(${args[0]}...${args[1]}).to_a` : `(0...${args[0]}).to_a`;
+      case 'abs': return `${args[0]}.abs`;
+      case 'round': return `${args[0]}.round`;
+      case 'ceil': return `${args[0]}.ceil`;
+      case 'floor': return `${args[0]}.floor`;
+      case 'sqrt': return `Math.sqrt(${args[0]})`;
+      case 'pow': return `${args[0]} ** ${args[1]}`;
+      case 'sum': return `${args[0]}.sum`;
+      case 'flat': return `${args[0]}.flatten`;
+      case 'zip': return `${args[0]}.zip(${args[1]})`;
+      case 'chunk': return `${args[0]}.each_slice(${args[1]}).to_a`;
+      case 'str': return `${args[0]}.to_s`;
+      case 'int': return `${args[0]}.to_i`;
+      case 'float': return `${args[0]}.to_f`;
+      case 'json_parse': return `JSON.parse(${args[0]})`;
+      case 'json_str': return `JSON.generate(${args[0]})`;
+      case 'now': return `(Time.now.to_f * 1000).to_i`;
+      case 'time': return `Time.now.iso8601`;
+      case 'exit': return `exit(${args[0] || '0'})`;
+      case 'sleep': return `sleep(${args[0]} / 1000.0)`;
+      case 'random': return args.length >= 2 ? `rand(${args[0]}..${args[1]})` : `rand`;
+      case 'read': return `File.read(${args[0]})`;
+      case 'write': return `File.write(${args[0]}, ${args[1]})`;
+      case 'ask': return `(print(${args[0] || '""'}); gets.chomp)`;
+      default: return null;
+    }
+  }
 }

package/src/generator-rust.js

@@ -207,6 +207,8 @@ export class RustGenerator {
       case 'GrpcDecl': return this.visitGrpc(node);
       case 'WebrtcDecl': return this.visitWebrtc(node);
       case 'BlockchainDecl': return this.visitBlockchain(node);
+      case 'EnumDecl': return this.visitEnum(node);
+      case 'Swap': return this.visitSwap(node);
       default:
         this.emit(`/* unknown: ${node.type} */`);
     }
@@ -1707,6 +1709,12 @@ export class RustGenerator {
   }
 
   generateCall(node) {
+    if (node.callee.type === 'Identifier') {
+      const argList = node.args.map(a => this.expr(a));
+      const b = this.generateBuiltin(node.callee.name, argList);
+      if (b) return b;
+    }
+
     const args = node.args.map(a => this.expr(a)).join(', ');
 
     // Map common JS global functions to Rust
@@ -1884,4 +1892,57 @@ export class RustGenerator {
     this.indent = savedIndent;
     return result;
   }
+
+  visitEnum(node) {
+    this.emit(`#[derive(Debug, Clone, Copy, PartialEq)]`);
+    this.emit(`enum ${node.name} {`);
+    this.indent++;
+    node.values.forEach(v => {
+      this.emit(`${v},`);
+    });
+    this.indent--;
+    this.emit(`}`);
+    this.emitRaw('');
+  }
+
+  visitSwap(node) {
+    const a = this.expr(node.a);
+    const b = this.expr(node.b);
+    this.emit(`std::mem::swap(&mut ${a}, &mut ${b});`);
+  }
+
+  generateBuiltin(name, args) {
+    switch (name) {
+      case 'len': return `${args[0]}.len()`;
+      case 'str': return `${args[0]}.to_string()`;
+      case 'int': return `${args[0]}.parse::<i64>().unwrap_or(0)`;
+      case 'float': return `${args[0]}.parse::<f64>().unwrap_or(0.0)`;
+      case 'upper': return `${args[0]}.to_uppercase()`;
+      case 'lower': return `${args[0]}.to_lowercase()`;
+      case 'trim': return `${args[0]}.trim().to_string()`;
+      case 'split': return `${args[0]}.split(${args[1] || '","'}).collect::<Vec<&str>>()`;
+      case 'join': return `${args[0]}.join(${args[1] || '","'})`;
+      case 'contains': return `${args[0]}.contains(${args[1]})`;
+      case 'replace': return `${args[0]}.replace(${args[1]}, ${args[2]})`;
+      case 'sort': return `{ let mut v = ${args[0]}.clone(); v.sort(); v }`;
+      case 'reverse': return `{ let mut v = ${args[0]}.clone(); v.reverse(); v }`;
+      case 'abs': return `${args[0]}.abs()`;
+      case 'sqrt': return `(${args[0]} as f64).sqrt()`;
+      case 'pow': return `(${args[0]} as f64).powi(${args[1]} as i32)`;
+      case 'ceil': return `(${args[0]} as f64).ceil()`;
+      case 'floor': return `(${args[0]} as f64).floor()`;
+      case 'round': return `(${args[0]} as f64).round()`;
+      case 'sum': return `${args[0]}.iter().sum::<i64>()`;
+      case 'unique': return `{ let mut v = ${args[0]}.clone(); v.sort(); v.dedup(); v }`;
+      case 'exit': return `std::process::exit(${args[0] || '0'})`;
+      case 'sleep': return `std::thread::sleep(std::time::Duration::from_millis(${args[0]} as u64))`;
+      case 'now': return `std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_millis() as i64`;
+      case 'random': return args.length >= 2 ? `rand::thread_rng().gen_range(${args[0]}..=${args[1]})` : `rand::random::<f64>()`;
+      case 'keys': return `${args[0]}.keys().cloned().collect::<Vec<_>>()`;
+      case 'values': return `${args[0]}.values().cloned().collect::<Vec<_>>()`;
+      case 'range': return args.length >= 2 ? `(${args[0]}..${args[1]}).collect::<Vec<_>>()` : `(0..${args[0]}).collect::<Vec<_>>()`;
+      case 'flat': return `${args[0]}.into_iter().flatten().collect::<Vec<_>>()`;
+      default: return null;
+    }
+  }
 }

package/src/generator-swift.js

@@ -139,6 +139,8 @@ export class SwiftGenerator {
       case 'GrpcDecl': return this.visitGrpc(node);
       case 'WebrtcDecl': return this.visitWebrtc(node);
       case 'BlockchainDecl': return this.visitBlockchain(node);
+      case 'EnumDecl': return this.visitEnum(node);
+      case 'Swap': return this.visitSwap(node);
       default:
         this.emit(`// unknown: ${node.type}`);
     }
@@ -1555,6 +1557,12 @@ export class SwiftGenerator {
   }
 
   generateCall(node) {
+    if (node.callee.type === 'Identifier') {
+      const argList = node.args.map(a => this.expr(a));
+      const b = this.generateBuiltin(node.callee.name, argList);
+      if (b) return b;
+    }
+
     const args = node.args.map(a => this.expr(a)).join(', ');
 
     if (node.callee.type === 'Identifier') {
@@ -1732,4 +1740,63 @@ export class SwiftGenerator {
     this.indent = savedIndent;
     return result;
   }
+
+  visitEnum(node) {
+    this.emit(`enum ${node.name}: Int, CaseIterable {`);
+    this.indent++;
+    node.values.forEach((v, i) => {
+      this.emit(`case ${v.toLowerCase()} = ${i}`);
+    });
+    this.indent--;
+    this.emit(`}`);
+    this.emitRaw('');
+  }
+
+  visitSwap(node) {
+    const a = this.expr(node.a);
+    const b = this.expr(node.b);
+    this.emit(`swap(&${a}, &${b})`);
+  }
+
+  generateBuiltin(name, args) {
+    switch (name) {
+      case 'len': return `${args[0]}.count`;
+      case 'sort': return `${args[0]}.sorted()`;
+      case 'reverse': return `${args[0]}.reversed()`;
+      case 'unique': return `Array(Set(${args[0]}))`;
+      case 'upper': return `${args[0]}.uppercased()`;
+      case 'lower': return `${args[0]}.lowercased()`;
+      case 'trim': return `${args[0]}.trimmingCharacters(in: .whitespacesAndNewlines)`;
+      case 'split': return `${args[0]}.components(separatedBy: ${args[1] || '","'})`;
+      case 'join': return `${args[0]}.joined(separator: ${args[1] || '","'})`;
+      case 'contains': return `${args[0]}.contains(${args[1]})`;
+      case 'replace': return `${args[0]}.replacingOccurrences(of: ${args[1]}, with: ${args[2]})`;
+      case 'keys': return `Array(${args[0]}.keys)`;
+      case 'values': return `Array(${args[0]}.values)`;
+      case 'range': return args.length >= 2 ? `Array(${args[0]}..<${args[1]})` : `Array(0..<${args[0]})`;
+      case 'abs': return `abs(${args[0]})`;
+      case 'sqrt': { this.addImport('Foundation'); return `sqrt(Double(${args[0]}))`; }
+      case 'pow': { this.addImport('Foundation'); return `pow(Double(${args[0]}), Double(${args[1]}))`; }
+      case 'ceil': { this.addImport('Foundation'); return `ceil(Double(${args[0]}))`; }
+      case 'floor': { this.addImport('Foundation'); return `floor(Double(${args[0]}))`; }
+      case 'round': { this.addImport('Foundation'); return `round(Double(${args[0]}))`; }
+      case 'sum': return `${args[0]}.reduce(0, +)`;
+      case 'flat': return `${args[0]}.flatMap { $0 }`;
+      case 'zip': return `Array(zip(${args[0]}, ${args[1]}))`;
+      case 'chunk': return `stride(from: 0, to: ${args[0]}.count, by: ${args[1]}).map { Array(${args[0]}[$0..<min($0+${args[1]}, ${args[0]}.count)]) }`;
+      case 'str': return `String(${args[0]})`;
+      case 'int': return `Int(${args[0]}) ?? 0`;
+      case 'float': return `Double(${args[0]}) ?? 0.0`;
+      case 'json_parse': { this.addImport('Foundation'); return `try? JSONSerialization.jsonObject(with: ${args[0]}.data(using: .utf8)!, options: [])`; }
+      case 'json_str': { this.addImport('Foundation'); return `String(data: try! JSONSerialization.data(withJSONObject: ${args[0]}), encoding: .utf8)!`; }
+      case 'now': { this.addImport('Foundation'); return `Int(Date().timeIntervalSince1970 * 1000)`; }
+      case 'time': { this.addImport('Foundation'); return `ISO8601DateFormatter().string(from: Date())`; }
+      case 'exit': { this.addImport('Foundation'); return `exit(${args[0] || '0'})`; }
+      case 'sleep': { this.addImport('Foundation'); return `Thread.sleep(forTimeInterval: Double(${args[0]}) / 1000.0)`; }
+      case 'random': return args.length >= 2 ? `Int.random(in: ${args[0]}...${args[1]})` : `Double.random(in: 0...1)`;
+      case 'read': return `try! String(contentsOfFile: ${args[0]})`;
+      case 'write': return `try! ${args[1]}.write(toFile: ${args[0]}, atomically: true, encoding: .utf8)`;
+      default: return null;
+    }
+  }
 }

package/src/parser.js

@@ -135,7 +135,18 @@ export class Parser {
 
   error(msg, tok) {
     const t = tok || this.peek();
-    return new Error(`[NAIDE Parse Error] ${msg} at line ${t.line}:${t.col}`);
+    let hint = '';
+    const v = t.value;
+    if (v === 'unless') hint = '\n  Hint: unless <condition>:';
+    else if (v === 'until') hint = '\n  Hint: until <condition>:';
+    else if (v === 'repeat') hint = '\n  Hint: repeat <count>:  or  repeat <count> as <var>:';
+    else if (v === 'swap') hint = '\n  Hint: swap <a>, <b>';
+    else if (v === 'enum') hint = '\n  Hint: enum <Name>:  then indent values';
+    else if (v === 'fn') hint = '\n  Hint: fn <name>(<params>) -> <type>:  or  fn <name>(<params>) -> <type> = <expr>';
+    else if (v === 'if') hint = '\n  Hint: if <condition>:';
+    else if (v === 'for') hint = '\n  Hint: for <var> in <iterable>:';
+    else if (v === 'while') hint = '\n  Hint: while <condition>:';
+    return new Error(`[NAIDE Parse Error] ${msg} at line ${t.line}:${t.col}${hint}`);
   }
 
   skipNewlines() {