novac 2.1.1 → 2.2.0

package/src/core/executor.js

@@ -4,6 +4,7 @@ const {
   NovaStruct, NovaEnum, NOVA_META,
 } = require('./types.js');
 const { CustomError, formatError, NovaException } = require('./error');
+const { atob } = require('buffer');
 
 // ── Default sentinel ─────────────────────────────────────────────────────────
 // When `default` is passed as a function argument, the parameter's declared
@@ -193,8 +194,34 @@ class Executor {
     this.novaServers = new Map();   // port -> routes[], for in-process dispatch
     this.dot_commands = {
       print: (...args) => {
-         console.log(...args.map(a=>_self.evaluate(a)));
-      }
+        console.log(...args.map(a => _self.evaluate(a)));
+      },
+      clear: () => process.stdout.write('\x1Bc'),
+      code: () => 0, // no-op, used for doc comments that should be ignored by the executor but visible to external tools
+      zap: (target) => {
+        const t = this.evaluate(target);
+        if (t instanceof NovaObject) {
+          for (const k of Object.keys(t.inner)) delete t.inner[k];
+        } else if (t instanceof NovaStruct) {
+          for (const k of Object.keys(t.inner)) delete t.inner[k];
+        } else if (t && typeof t === 'object') {
+          for (const k of Object.keys(t)) delete t[k];
+        } else {
+          throw new Error('.zap target must be an object or struct instance');
+        }
+      },
+      cookie() {
+        const asciiCookie = `(\\_/)
+( •_•)
+/ >🍪   Here's a cookie for you!`;
+        console.log(asciiCookie);
+      },
+      js: (code) => {
+        const codeStr = this.evaluate(code);
+        if (typeof codeStr === 'string') eval(codeStr);
+        else if (codeStr instanceof NovaString) eval(codeStr.value);
+        else throw new Error('.js command requires a string argument');
+      },
     }
     this.moduleExportsStack = [];
     this.options = {};
@@ -203,21 +230,44 @@ class Executor {
     this.globalScope.variables.std = stdlib;
     const self = this;
 
-this.globalScope.set('setTimeout', setTimeout);
-this.globalScope.set('clearTimeout', clearTimeout);
-this.globalScope.set('setInterval', setInterval);
-this.globalScope.set('clearInterval', clearInterval);
-this.globalScope.set('setImmediate', setImmediate);
-this.globalScope.set('clearImmediate', clearImmediate);
-this.globalScope.set('queueMicrotask', queueMicrotask);
-this.globalScope.set('parseInt', parseInt);
-this.globalScope.set('parseFloat', parseFloat);
-this.globalScope.set('isNaN', isNaN);
-this.globalScope.set('isFinite', isFinite);
-this.globalScope.set('sleepAsync', (ms)=>new Promise(r=>setTimeout(r,ms)));
-this.globalScope.set('Scope', Scope);
-// Expose the default sentinel so runtime code can detect it
-this.globalScope.set('__DEFAULT_SENTINEL__', DEFAULT_SENTINEL);
+    this.globalScope.set('avaibleKits', (() => {
+      const kits = [];
+      const kitsDir = require('path').join(__dirname, '../..', 'kits');
+      try {
+        const fs = require('fs');
+        for (const kitName of fs.readdirSync(kitsDir)) {
+          kits.push(kitName)
+        }
+      } catch (e) {
+        console.warn('Could not load kits:', e.message);
+      }
+      return kits;
+    })());
+    this.globalScope.set('setTimeout', setTimeout);
+    this.globalScope.set('clearTimeout', clearTimeout);
+    this.globalScope.set('setInterval', setInterval);
+    this.globalScope.set('clearInterval', clearInterval);
+    this.globalScope.set('setImmediate', setImmediate);
+    this.globalScope.set('clearImmediate', clearImmediate);
+    this.globalScope.set('queueMicrotask', queueMicrotask);
+    this.globalScope.set('parseInt', parseInt);
+    this.globalScope.set('parseFloat', parseFloat);
+    this.globalScope.set('isNaN', isNaN);
+    this.globalScope.set('isFinite', isFinite);
+    this.globalScope.set('sleepAsync', (ms) => new Promise(r => setTimeout(r, ms)));
+    this.globalScope.set('Scope', Scope);
+    this.globalScope.set('Atomics', Atomics);
+    this.globalScope.set('SharedArrayBuffer', SharedArrayBuffer);
+    this.globalScope.set('Buffer', Buffer);
+    this.globalScope.set('CError', CustomError);
+    this.globalScope.set('Error', Error);
+    //remaining built in nodejs variables and objects excluding global, process, console (which we want to control access to), and a few others for safety
+    this.globalScope.set('textEncoder', TextEncoder);
+    this.globalScope.set('textDecoder', TextDecoder);
+    this.globalScope.set('Util', require('util'));
+    this.globalScope.set('Date', Date);
+    // Expose the default sentinel so runtime code can detect it
+    this.globalScope.set('__DEFAULT_SENTINEL__', DEFAULT_SENTINEL);
 
     this.globalScope.set('core', {
       getAst: () => this.ast,
@@ -314,7 +364,7 @@ this.globalScope.set('__DEFAULT_SENTINEL__', DEFAULT_SENTINEL);
       check: (a, pred) => typeof pred === 'function' ? pred(a) : (_qae[pred] ? _qae[pred](a) : false),
     };
     this.globalScope.set('qae', _qae);
-    this.globalScope.set('novaRegex', (pattern, flags) => this._novaRegex(pattern, flags || ''));
+    this.globalScope.set('cregex', (pattern, flags) => this._novaRegex(pattern, flags || ''));
 
     // ── Sync HTTP fetch ──
     const _self = this;
@@ -423,7 +473,7 @@ this.globalScope.set('__DEFAULT_SENTINEL__', DEFAULT_SENTINEL);
       info: (msg) => process.stdout.write('INFO: ' + String(msg) + '\n'),
     };
     this.globalScope.set('nvk', nvk);
-
+    this.globalScope.set('charAt', String.fromCharCode);
     // ── waitsync(fn, ...args) ─────────────────────────────────────────────
     // Calls fn(...args) and blocks synchronously until the result settles,
     // whether the function is:
@@ -457,14 +507,14 @@ this.globalScope.set('__DEFAULT_SENTINEL__', DEFAULT_SENTINEL);
       // Shared memory layout (Int32Array, 3 slots):
       //   [0]  flag:   0=pending, 1=resolved, 2=rejected
       //   [1-2] unused (value is passed via a separate Buffer)
-      const sab   = new SharedArrayBuffer(4);
-      const flag  = new Int32Array(sab);
+      const sab = new SharedArrayBuffer(4);
+      const flag = new Int32Array(sab);
 
       // We pass the resolved/rejected value as a JSON string through a
       // larger shared buffer (up to 4 MB).  For values that can't be
       // JSON-serialised we fall back to null.
       const valueBufSize = 4 * 1024 * 1024; // 4 MB
-      const valueSab  = new SharedArrayBuffer(valueBufSize + 4); // +4 for length prefix
+      const valueSab = new SharedArrayBuffer(valueBufSize + 4); // +4 for length prefix
       const valueMeta = new Int32Array(valueSab, 0, 1);  // [0] = byte length
       const valueData = new Uint8Array(valueSab, 4);     // rest = UTF-8 bytes
 
@@ -520,9 +570,9 @@ p.then((v) => {
       // Atomics.wait call.  The main thread does the actual resolution.
       result.then((v) => {
         try {
-          const json  = JSON.stringify(v === undefined ? null : v);
+          const json = JSON.stringify(v === undefined ? null : v);
           const bytes = Buffer.from(json, 'utf8');
-          const len   = Math.min(bytes.length, valueData.length);
+          const len = Math.min(bytes.length, valueData.length);
           bytes.copy(Buffer.from(valueData.buffer, valueData.byteOffset), 0, 0, len);
           Atomics.store(valueMeta, 0, len);
           Atomics.store(flag, 0, 1);
@@ -534,9 +584,9 @@ p.then((v) => {
         }
       }).catch((e) => {
         try {
-          const msg   = e && e.message ? e.message : String(e);
+          const msg = e && e.message ? e.message : String(e);
           const bytes = Buffer.from(JSON.stringify(msg), 'utf8');
-          const len   = Math.min(bytes.length, valueData.length);
+          const len = Math.min(bytes.length, valueData.length);
           bytes.copy(Buffer.from(valueData.buffer, valueData.byteOffset), 0, 0, len);
           Atomics.store(valueMeta, 0, len);
         } catch (_) { Atomics.store(valueMeta, 0, 0); }
@@ -598,19 +648,19 @@ Atomics.wait(flag, 0, 0);
 
       const { Worker } = require('worker_threads');
 
-      const sab        = new SharedArrayBuffer(4);
-      const flag       = new Int32Array(sab);
+      const sab = new SharedArrayBuffer(4);
+      const flag = new Int32Array(sab);
       const valueBufSize = 4 * 1024 * 1024;
-      const valueSab   = new SharedArrayBuffer(valueBufSize + 4);
-      const valueMeta  = new Int32Array(valueSab, 0, 1);
-      const valueData  = new Uint8Array(valueSab, 4);
+      const valueSab = new SharedArrayBuffer(valueBufSize + 4);
+      const valueMeta = new Int32Array(valueSab, 0, 1);
+      const valueData = new Uint8Array(valueSab, 4);
 
       // Attach resolution handlers in the main thread — microtasks fire here
       promise.then((v) => {
         try {
-          const json  = JSON.stringify(v === undefined ? null : v);
+          const json = JSON.stringify(v === undefined ? null : v);
           const bytes = Buffer.from(json, 'utf8');
-          const len   = Math.min(bytes.length, valueData.length);
+          const len = Math.min(bytes.length, valueData.length);
           bytes.copy(Buffer.from(valueData.buffer, valueData.byteOffset), 0, 0, len);
           Atomics.store(valueMeta, 0, len);
           Atomics.store(flag, 0, 1);
@@ -622,9 +672,9 @@ Atomics.wait(flag, 0, 0);
         }
       }).catch((e) => {
         try {
-          const msg   = e && e.message ? e.message : String(e);
+          const msg = e && e.message ? e.message : String(e);
           const bytes = Buffer.from(JSON.stringify(msg), 'utf8');
-          const len   = Math.min(bytes.length, valueData.length);
+          const len = Math.min(bytes.length, valueData.length);
           bytes.copy(Buffer.from(valueData.buffer, valueData.byteOffset), 0, 0, len);
           Atomics.store(valueMeta, 0, len);
         } catch (_) { Atomics.store(valueMeta, 0, 0); }
@@ -643,7 +693,7 @@ Atomics.wait(flag, 0, 0);
       Atomics.wait(flag, 0, 0);
       waiter.terminate();
 
-      const status  = Atomics.load(flag, 0);
+      const status = Atomics.load(flag, 0);
       const byteLen = Atomics.load(valueMeta, 0);
       let parsed = null;
       if (byteLen > 0) {
@@ -777,8 +827,8 @@ Atomics.wait(flag, 0, 0);
       // guards, interceptors, tasks/jobs, handlers, services, resources,
       // schemas — all injected as plain named functions/objects in scope
       const injectGroups = [
-        'filters','transforms','validators','decorators','reducers','effects',
-        'guards','interceptors','handlers','services','resources','schemas',
+        'filters', 'transforms', 'validators', 'decorators', 'reducers', 'effects',
+        'guards', 'interceptors', 'handlers', 'services', 'resources', 'schemas',
       ];
       for (const group of injectGroups) {
         const g = mod[group] || {};
@@ -813,13 +863,13 @@ Atomics.wait(flag, 0, 0);
       // init / setup — called once at load time
       const initFn = mod.init || mod.setup;
       if (typeof initFn === 'function') {
-        try { initFn(_self); } catch (_) {}
+        try { initFn(_self); } catch (_) { }
       }
 
       // teardown — called at process exit
       const teardownFn = mod.teardown;
       if (typeof teardownFn === 'function') {
-        process.on('exit', () => { try { teardownFn(); } catch (_) {} });
+        process.on('exit', () => { try { teardownFn(); } catch (_) { } });
       }
 
       // meta / docs / provides / permissions / dependencies — informational only
@@ -842,10 +892,10 @@ Atomics.wait(flag, 0, 0);
     // merges any exported names directly into it (same as a bare import).
     // Accepts .nova / .nv (parsed + executed) or .js (require()'d as a JS kit).
     this.globalScope.set('include', (filePath) => {
-      const _fs  = require('fs');
+      const _fs = require('fs');
       const _pth = require('path');
-      const src  = String(filePath);
-      const abs  = _pth.isAbsolute(src)
+      const src = String(filePath);
+      const abs = _pth.isAbsolute(src)
         ? src
         : _pth.resolve(process.cwd(), src);
 
@@ -890,25 +940,24 @@ Atomics.wait(flag, 0, 0);
     // falling back to index.nova if no kitdef.js exists.
     // The kit's exported namespace is merged into global scope AND returned.
     this.globalScope.set('includeKit', (kitName) => {
-      const _fs  = require('fs');
+      const _fs = require('fs');
       const _pth = require('path');
       const name = String(kitName);
       const kitsRoot = _pth.join(__dirname, '..', '..', 'kits');
-      const kitDir   = _pth.join(kitsRoot, name);
+      const kitDir = _pth.join(kitsRoot, name);
 
       if (!_fs.existsSync(kitDir)) {
         throw new Error(`includeKit: kit "${name}" not found at ${kitDir}`);
       }
 
-      const kitdefPath  = _pth.join(kitDir, 'kitdef.js');
-      const indexNova   = _pth.join(kitDir, 'index.nova');
-      const indexNv     = _pth.join(kitDir, 'index.nv');
+      const kitdefPath = _pth.join(kitDir, 'kitdef.js');
+      const indexNova = _pth.join(kitDir, 'index.nova');
+      const indexNv = _pth.join(kitDir, 'index.nv');
 
       if (_fs.existsSync(kitdefPath)) {
         // JS kit — load via require and process all metadata fields
         const mod = require(kitdefPath);
         if (!mod || !mod.kitdef) throw new Error(`includeKit: "${name}/kitdef.js" must export { kitdef }`);
-        _self._processKitMod(mod, name);
         return new NovaObject(mod.kitdef);
       }
 
@@ -941,6 +990,16 @@ Atomics.wait(flag, 0, 0);
       return '';
     });
 
+    this.globalScope.set('printr', (...args) => {
+      process.stdout.write(args.join(' ') + '\n');
+      return '';
+    });
+
+    this.globalScope.set('eprintr', (...args) => {
+      process.stderr.write(args.join(' ') + '\n');
+      return '';
+    });
+
     // ── println(...args) / eprint(...args) ──────────────────────────────
     this.globalScope.set('println', (...args) => {
       process.stdout.write(args.map(a => _self.stringify(a)).join(' ') + '\n');
@@ -955,7 +1014,7 @@ Atomics.wait(flag, 0, 0);
     // Pretty-prints a value with type info — useful for debugging.
     this.globalScope.set('dump', (v) => {
       const type = _self._typeOf(v);
-      const str  = _self.stringify(v);
+      const str = _self.stringify(v);
       process.stdout.write(`[${type}] ${str}\n`);
       return v;
     });
@@ -978,7 +1037,7 @@ Atomics.wait(flag, 0, 0);
       if (st === 0) throw new Error('range: step cannot be 0');
       const out = [];
       if (st > 0) { for (let i = s; i < e; i += st) out.push(i); }
-      else         { for (let i = s; i > e; i += st) out.push(i); }
+      else { for (let i = s; i > e; i += st) out.push(i); }
       return new NovaArray(out);
     });
 
@@ -1011,17 +1070,17 @@ Atomics.wait(flag, 0, 0);
 
     // ── parseInt / parseFloat / isNaN / isFinite ─────────────────────────
     // Expose JS globals directly so Nova scripts can use them without prefix.
-    this.globalScope.set('parseInt',   (v, radix) => parseInt(String(v), radix));
-    this.globalScope.set('parseFloat', (v)        => parseFloat(String(v)));
-    this.globalScope.set('isNaN',      (v)        => isNaN(v));
-    this.globalScope.set('isFinite',   (v)        => isFinite(v));
+    this.globalScope.set('parseInt', (v, radix) => parseInt(String(v), radix));
+    this.globalScope.set('parseFloat', (v) => parseFloat(String(v)));
+    this.globalScope.set('isNaN', (v) => isNaN(v));
+    this.globalScope.set('isFinite', (v) => isFinite(v));
 
     // ── keys(obj) / values(obj) / entries(obj) ──────────────────────────
-    this.globalScope.set('keys',    (o) => {
+    this.globalScope.set('keys', (o) => {
       const raw = o instanceof NovaObject ? o.inner : o;
       return new NovaArray(Object.keys(raw ?? {}));
     });
-    this.globalScope.set('values',  (o) => {
+    this.globalScope.set('values', (o) => {
       const raw = o instanceof NovaObject ? o.inner : o;
       return new NovaArray(Object.values(raw ?? {}));
     });
@@ -1030,15 +1089,63 @@ Atomics.wait(flag, 0, 0);
       return new NovaArray(Object.entries(raw ?? {}).map(([k, v]) => new NovaArray([k, v])));
     });
 
+    // ── Wasm ──────────────────────────────────────────────────────────────
+    // Wasm object with many methods
+    this.globalScope.set('Wasm', {
+      run: async (bytes, imports) => {
+        const module = await WebAssembly.compile(bytes instanceof NovaArray ? new Uint8Array(bytes.inner) : bytes);
+        const instance = await WebAssembly.instantiate(module, imports instanceof NovaObject ? imports.inner : imports);
+        if (instance.exports && typeof instance.exports._start === 'function') {
+          return instance.exports._start();
+        }
+        return instance;
+      },
+      ...WebAssembly, // re-export all WebAssembly static methods/properties
+    })
     // ── len(v) ───────────────────────────────────────────────────────────
     this.globalScope.set('len', (v) => {
-      if (v instanceof NovaArray)  return v.length;
+      if (v instanceof NovaArray) return v.length;
       if (v instanceof NovaObject) return Object.keys(v.inner).length;
-      if (typeof v === 'string')   return v.length;
+      if (typeof v === 'string') return v.length;
       if (v && v.length !== undefined) return v.length;
       return 0;
     });
-
+    // ── new WaiterObject() ───────────────────────────────────────────────────
+    // Expose the WaiterObject class so Nova scripts can create waiters directly.
+    class WaiterObject { // a waiter is an object like this: { state: Int, value: any }
+      constructor() {
+        this._state = 0; // 0 = pending, 1 = resolved, 2 = rejected
+        this.value = null;
+        this.onStateChange = (newState) => newState; // override this to react to state changes
+      }
+      get state() { return this._state; }
+      set state(v) { this._state = this.onStateChange(Number(v)); }
+    }
+    this.globalScope.set('WaiterObject', WaiterObject);
+    // ── new Mutex() ───────────────────────────────────────────────────────────
+    // Expose a simple Mutex class for mutual exclusion in async code.
+    class Mutex {
+      constructor(...waiters) {
+        this._locked = false;
+        this._waiters = waiters;
+      }
+      lock() {
+        if (!this._locked) {
+          this._locked = true;
+          return Promise.resolve();
+        }
+        return new Promise(resolve => this._waiters.push(resolve));
+      }
+      unlock() {
+        if (this._waiters.length > 0) {
+          const next = this._waiters.shift();
+          next();
+        } else {
+          this._locked = false;
+        }
+      }
+    }
+    this.globalScope.set('Mutex', Mutex);
     // ── typeOf_(v) ───────────────────────────────────────────────────────
     // Returns a string type name for any nova value.
     // Named typeOf_ to avoid collision with the `type` keyword (type declarations).
@@ -1046,8 +1153,8 @@ Atomics.wait(flag, 0, 0);
     this.globalScope.set('typeOf_', (v) => _self._typeOf(v));
 
     // ── str(v) / num(v) / bool(v) ────────────────────────────────────────
-    this.globalScope.set('str',  (v) => _self.stringify(v));
-    this.globalScope.set('num',  (v) => Number(v instanceof NovaValue ? v.valueOf() : v));
+    this.globalScope.set('str', (v) => _self.stringify(v));
+    this.globalScope.set('num', (v) => Number(v instanceof NovaValue ? v.valueOf() : v));
     this.globalScope.set('bool', (v) => {
       const raw = v instanceof NovaBool ? v.valueOf() : v;
       return !!raw;
@@ -1061,8 +1168,8 @@ Atomics.wait(flag, 0, 0);
     // Named zipArrays to avoid collision with nova's infix `zip` operator.
     this.globalScope.set('zipArrays', (...arrays) => {
       const arrs = arrays.map(a => a instanceof NovaArray ? a.inner : a);
-      const len  = Math.min(...arrs.map(a => a.length));
-      const out  = [];
+      const len = Math.min(...arrs.map(a => a.length));
+      const out = [];
       for (let i = 0; i < len; i++) out.push(new NovaArray(arrs.map(a => a[i])));
       return new NovaArray(out);
     });
@@ -1121,13 +1228,13 @@ Atomics.wait(flag, 0, 0);
       if (t === 'symbol') return v;
       if (t !== 'object') return v;
       if (seen.has(v)) return seen.get(v);
-      if (v instanceof NovaBool)   return new NovaBool(v.valueOf());
-      if (v instanceof NovaNull)   return new NovaNull();
+      if (v instanceof NovaBool) return new NovaBool(v.valueOf());
+      if (v instanceof NovaNull) return new NovaNull();
       if (v instanceof NovaNumber) return new NovaNumber(v.valueOf());
       if (v instanceof NovaString) return new NovaString(v.valueOf());
-      if (v instanceof NovaRange)  return new NovaRange(v.start, v.end, v.step);
+      if (v instanceof NovaRange) return new NovaRange(v.start, v.end, v.step);
       if (v instanceof NovaPointer) return new NovaPointer(_deepClone(v.inner, seen), v.readFn, v.writeFn, v.address);
-      if (v instanceof NovaEnum)   { const e = new NovaEnum(v.typeName, v.variant, _deepClone(v.inner, seen)); e.value = _deepClone(v.value, seen); return e; }
+      if (v instanceof NovaEnum) { const e = new NovaEnum(v.typeName, v.variant, _deepClone(v.inner, seen)); e.value = _deepClone(v.value, seen); return e; }
       if (v instanceof NovaStruct) {
         const inner = {};
         seen.set(v, inner); // register early to handle circular refs
@@ -1177,10 +1284,10 @@ Atomics.wait(flag, 0, 0);
     // ── shallowClone(value) ───────────────────────────────────────────────
     // One-level clone — top container is new but inner values are shared.
     this.globalScope.set('shallowClone', (v) => {
-      if (v instanceof NovaArray)  return new NovaArray([...v.inner]);
+      if (v instanceof NovaArray) return new NovaArray([...v.inner]);
       if (v instanceof NovaObject) return new NovaObject({ ...v.inner });
       if (v instanceof NovaStruct) return new NovaStruct(v.typeName, { ...v.inner });
-      if (Array.isArray(v))        return [...v];
+      if (Array.isArray(v)) return [...v];
       if (v && typeof v === 'object') return { ...v };
       return v;
     });
@@ -1193,7 +1300,7 @@ Atomics.wait(flag, 0, 0);
     // executor's globalScope since Nova scripts can't pass their own scope ref.
     this.globalScope.set('saveCurrentScope', () => {
       const snap = new Scope('saved', null, _self.globalScope);
-      const SKIP = new Set(['scope','array','std','globalScope','parent']);
+      const SKIP = new Set(['scope', 'array', 'std', 'globalScope', 'parent']);
       for (const [k, v] of Object.entries(_self.globalScope.variables)) {
         if (SKIP.has(k)) continue;
         try { snap.variables[k] = _deepClone(v); } catch { snap.variables[k] = v; }
@@ -1214,7 +1321,7 @@ Atomics.wait(flag, 0, 0);
       if (!(scope instanceof Scope))
         throw new Error('saveScope: argument must be a Scope (got ' + _self._typeOf(scope) + ')');
       const snap = new Scope('saved', null, _self.globalScope);
-      const SKIP = new Set(['scope','array','std','globalScope','parent']);
+      const SKIP = new Set(['scope', 'array', 'std', 'globalScope', 'parent']);
       for (const [k, v] of Object.entries(scope.variables)) {
         if (SKIP.has(k)) continue;
         try { snap.variables[k] = _deepClone(v); } catch { snap.variables[k] = v; }
@@ -1230,7 +1337,7 @@ Atomics.wait(flag, 0, 0);
     // the current global scope.  Good for inspection / serialization.
     this.globalScope.set('scopeSnapshot', (scope) => {
       const src = (scope instanceof Scope) ? scope : _self.globalScope;
-      const SKIP = new Set(['scope','array','std','globalScope','parent']);
+      const SKIP = new Set(['scope', 'array', 'std', 'globalScope', 'parent']);
       const out = {};
       for (const [k, v] of Object.entries(src.variables)) {
         if (SKIP.has(k)) continue;
@@ -1285,7 +1392,7 @@ Atomics.wait(flag, 0, 0);
     this.globalScope.set('scopeMerge', (target, source) => {
       if (!(target instanceof Scope) || !(source instanceof Scope))
         throw new Error('scopeMerge: both args must be Scopes');
-      const SKIP = new Set(['scope','array','std','globalScope','parent']);
+      const SKIP = new Set(['scope', 'array', 'std', 'globalScope', 'parent']);
       for (const [k, v] of Object.entries(source.variables)) {
         if (SKIP.has(k)) continue;
         target.variables[k] = v;
@@ -1326,7 +1433,7 @@ Atomics.wait(flag, 0, 0);
     // List all user-defined variable names in a scope (own only).
     this.globalScope.set('scopeKeys', (scope) => {
       const src = (scope instanceof Scope) ? scope : _self.globalScope;
-      const SKIP = new Set(['scope','array','std','globalScope','parent']);
+      const SKIP = new Set(['scope', 'array', 'std', 'globalScope', 'parent']);
       return new NovaArray(Object.keys(src.variables).filter(k => !SKIP.has(k)));
     });
 
@@ -1364,7 +1471,7 @@ Atomics.wait(flag, 0, 0);
     // Freeze all current variables in scope as constants (no further writes).
     this.globalScope.set('freezeScope', (scope) => {
       const src = (scope instanceof Scope) ? scope : _self.globalScope;
-      const SKIP = new Set(['scope','array','std','globalScope','parent']);
+      const SKIP = new Set(['scope', 'array', 'std', 'globalScope', 'parent']);
       for (const k of Object.keys(src.variables)) {
         if (!SKIP.has(k)) src.consts[k] = src.variables[k];
       }
@@ -1377,7 +1484,7 @@ Atomics.wait(flag, 0, 0);
     this.globalScope.set('scopeDiff', (a, b) => {
       if (!(a instanceof Scope) || !(b instanceof Scope))
         throw new Error('scopeDiff: both args must be Scopes');
-      const SKIP = new Set(['scope','array','std','globalScope','parent']);
+      const SKIP = new Set(['scope', 'array', 'std', 'globalScope', 'parent']);
       const keysA = new Set(Object.keys(a.variables).filter(k => !SKIP.has(k)));
       const keysB = new Set(Object.keys(b.variables).filter(k => !SKIP.has(k)));
       const onlyInA = [...keysA].filter(k => !keysB.has(k));
@@ -1401,13 +1508,13 @@ Atomics.wait(flag, 0, 0);
       const n = String(name);
       let _val = scope.variables[n];
       const descriptor = {
-        read:  () => _val,
+        read: () => _val,
         write: (v) => {
           const old = _val; _val = v;
           try {
             if (typeof fn === 'function') fn(v, old);
             else if (fn && fn.body !== undefined) _self.runFunctionNode(fn, _self.globalScope, [v, old]);
-          } catch (_) {}
+          } catch (_) { }
         },
       };
       scope.variables[n] = descriptor;
@@ -1463,7 +1570,7 @@ Atomics.wait(flag, 0, 0);
     const _deepFreeze = (v, seen = new WeakSet()) => {
       if (!v || typeof v !== 'object' || seen.has(v)) return v;
       seen.add(v);
-      if (v instanceof NovaArray)  { Object.freeze(v.inner); v.inner.forEach(x => _deepFreeze(x, seen)); }
+      if (v instanceof NovaArray) { Object.freeze(v.inner); v.inner.forEach(x => _deepFreeze(x, seen)); }
       if (v instanceof NovaObject) { Object.freeze(v.inner); Object.values(v.inner).forEach(x => _deepFreeze(x, seen)); }
       if (v instanceof NovaStruct) { Object.freeze(v.inner); Object.values(v.inner).forEach(x => _deepFreeze(x, seen)); }
       return v;
@@ -1666,7 +1773,7 @@ Atomics.wait(flag, 0, 0);
       if (st === 0) throw new Error('range2: step cannot be 0');
       const out = [];
       if (st > 0) { for (let i = s; i <= e; i += st) out.push(i); }
-      else         { for (let i = s; i >= e; i += st) out.push(i); }
+      else { for (let i = s; i >= e; i += st) out.push(i); }
       return new NovaArray(out);
     });
 
@@ -1919,7 +2026,7 @@ Atomics.wait(flag, 0, 0);
       const d = new Date(ms !== undefined ? Number(ms) : Date.now());
       const pad = (n) => String(n).padStart(2, '0');
       const tokens = {
-        YYYY: d.getFullYear(), MM: pad(d.getMonth()+1), DD: pad(d.getDate()),
+        YYYY: d.getFullYear(), MM: pad(d.getMonth() + 1), DD: pad(d.getDate()),
         HH: pad(d.getHours()), mm: pad(d.getMinutes()), ss: pad(d.getSeconds()),
       };
       const f = String(fmt || 'YYYY-MM-DD HH:mm:ss');
@@ -1950,7 +2057,7 @@ Atomics.wait(flag, 0, 0);
     // Return a human-readable debug string with type info.
     this.globalScope.set('inspect', (v) => {
       const type = _self._typeOf(v);
-      const str  = _self.stringify(v);
+      const str = _self.stringify(v);
       return `[${type}] ${str}`;
     });
 
@@ -1998,7 +2105,7 @@ Atomics.wait(flag, 0, 0);
     }
     // NovaBool / NovaNumber / NovaString / NovaNull — all have _v
     if (v instanceof NovaBool || v instanceof NovaNumber ||
-        v instanceof NovaString || v instanceof NovaNull) {
+      v instanceof NovaString || v instanceof NovaNull) {
       return { _v: v.valueOf !== undefined ? v.valueOf() : null };
     }
     if (v instanceof NovaRange) return { start: v.start, end: v.end };
@@ -2026,10 +2133,10 @@ Atomics.wait(flag, 0, 0);
     if (Array.isArray(v)) return v.map(x => this._rehydrate(x));
     if ('__jsfn__' in v) { try { return eval('(' + v.__jsfn__ + ')'); } catch { return null; } }
     if ('_v' in v) {
-      if (v._v === null)             return new NovaNull();
+      if (v._v === null) return new NovaNull();
       if (typeof v._v === 'boolean') return new NovaBool(v._v);
-      if (typeof v._v === 'number')  return new NovaNumber(v._v);
-      if (typeof v._v === 'string')  return new NovaString(v._v);
+      if (typeof v._v === 'number') return new NovaNumber(v._v);
+      if (typeof v._v === 'string') return new NovaString(v._v);
       return v._v;
     }
     if ('start' in v && 'end' in v && Object.keys(v).length === 2)
@@ -2070,12 +2177,12 @@ Atomics.wait(flag, 0, 0);
     // Also snapshot the global user-defined variables (functions, declared vars)
     // but skip built-in keys that are circular, huge, or executor-internal.
     const SKIP = new Set([
-      'scope','array','std','core','nova','nvk','qae','novaRegex','fetch',
-      'setTimeout','typecheck','satisfies','typeOf','Thread',
-      'ForLoop','WhileLoop','IfBlock','TryCatch','Pipeline','FuncDef',
-      'MatchBlock','Timer','Counter','Stack','Queue','LinkedList',
-      'State','Observable','Validator','DataStream','Transformer',
-      'TransformerJSON','TransformerBase64','Router','EventBus','Memo','Lazy','Signal',
+      'scope', 'array', 'std', 'core', 'nova', 'nvk', 'qae', 'cregex', 'fetch',
+      'setTimeout', 'typecheck', 'satisfies', 'typeOf', 'Thread',
+      'ForLoop', 'WhileLoop', 'IfBlock', 'TryCatch', 'Pipeline', 'FuncDef',
+      'MatchBlock', 'Timer', 'Counter', 'Stack', 'Queue', 'LinkedList',
+      'State', 'Observable', 'Validator', 'DataStream', 'Transformer',
+      'TransformerJSON', 'TransformerBase64', 'Router', 'EventBus', 'Memo', 'Lazy', 'Signal',
     ]);
     for (const [k, v] of Object.entries(this.globalScope.variables || {})) {
       if (SKIP.has(k) || snap.hasOwnProperty(k)) continue;
@@ -2091,20 +2198,20 @@ Atomics.wait(flag, 0, 0);
   _initThread() {
     const _path = require('path');
     const _workerScriptPath = _path.join(__dirname, 'nova_thread_worker.js');
-    const _executorPath     = _path.join(__dirname, 'executor.js');
+    const _executorPath = _path.join(__dirname, 'executor.js');
     const _exe = this;
 
     class NovaThread {
       constructor(fnNode, callerScope) {
-        this._fnNode      = fnNode;
+        this._fnNode = fnNode;
         this._callerScope = callerScope;
-        this._worker      = null;
-        this._mutations   = []; // { name, value } buffered until join()
+        this._worker = null;
+        this._mutations = []; // { name, value } buffered until join()
         this._msgHandlers = [];
-        this._done        = false;
-        this._result      = undefined;
-        this._error       = null;
-        this._sab  = new SharedArrayBuffer(8);
+        this._done = false;
+        this._result = undefined;
+        this._error = null;
+        this._sab = new SharedArrayBuffer(8);
         this._flag = new Int32Array(this._sab);
         this._proxy = this._makeProxy();
       }
@@ -2112,13 +2219,13 @@ Atomics.wait(flag, 0, 0);
       _makeProxy() {
         const t = this;
         return new NovaObject({
-          start:      ()   => { t.start(); return t._proxy; },
-          join:       ()   => t.join(),
-          send:       (v)  => { t.send(v); return t._proxy; },
+          start: () => { t.start(); return t._proxy; },
+          join: () => t.join(),
+          send: (v) => { t.send(v); return t._proxy; },
           on_message: (fn) => { t.on_message(fn); return t._proxy; },
-          get result()     { return t._result; },
-          get error()      { return t._error; },
-          get done()       { return t._done; },
+          get result() { return t._result; },
+          get error() { return t._error; },
+          get done() { return t._done; },
         });
       }
 
@@ -2503,143 +2610,189 @@ Atomics.wait(flag, 0, 0);
     return content;
   }
 
-stringify(v, indent = 0, seen = new WeakSet()) {
-  const pad = "  ".repeat(indent);
-
-  const color = {
-    reset: "\x1b[0m",
-    key: "\x1b[36m",
-    string: "\x1b[32m",
-    number: "\x1b[33m",
-    bool: "\x1b[35m",
-    null: "\x1b[90m",
-    func: "\x1b[31m",
-    circular: "\x1b[91m",
-  };
-
-  const nl = "\n";
-
-  const next = (x, i = indent + 1) =>
-    this.stringify(x, i, seen);
-
-  if (v === null || v === undefined)
-    return color.null + "null" + color.reset;
-
-  if (v instanceof NovaNull)
-    return color.null + "null" + color.reset;
+  stringify(v, indent = 0, seen = new WeakSet()) {
+    const pad = "  ".repeat(indent);
+
+    const color = {
+      reset: "\x1b[0m",
+      key: "\x1b[36m",
+      string: "\x1b[32m",
+      number: "\x1b[33m",
+      bool: "\x1b[35m",
+      null: "\x1b[90m",
+      func: "\x1b[31m",
+      circular: "\x1b[91m",
+    };
 
-  if (v instanceof NovaBool)
-    return color.bool + String(v.valueOf()) + color.reset;
+    const nl = "\n";
 
-  if (v instanceof NovaString)
-    return color.string + `"${v.valueOf()}"` + color.reset;
+    const next = (x, i = indent + 1) =>
+      this.stringify(x, i, seen);
 
-  if (v instanceof NovaNumber)
-    return color.number + String(v.valueOf()) + color.reset;
+    if (v === null || v === undefined)
+      return color.null + "null" + color.reset;
 
-  if (v instanceof Promise)
-    return color.func + `Promise [${v.name || "anon"}]` + color.reset;
+    if (v instanceof NovaNull)
+      return color.null + "null" + color.reset;
 
-  if (v instanceof NovaRange)
-    return v.toString();
+    if (v instanceof NovaBool)
+      return color.bool + String(v.valueOf()) + color.reset;
 
-  if (v instanceof NovaStruct)
-    return v.toString();
+    if (v instanceof NovaString)
+      return color.string + `"${v.valueOf()}"` + color.reset;
 
-  if (typeof v === "object" && v !== null) {
-    if (seen.has(v))
-      return color.circular + "[Circular]" + color.reset;
+    if (v instanceof NovaNumber)
+      return color.number + String(v.valueOf()) + color.reset;
 
-    seen.add(v);
-  }
+    if (v instanceof Promise)
+      return color.func + `Promise [${v.name || "anon"}]` + color.reset;
 
-  if (v instanceof NovaArray) {
-    if (!v.inner.length)
-      return "[]";
-
-    return "[\n" +
-      v.inner.map(x =>
-        pad + "  " + next(x, indent + 1)
-      ).join(",\n") +
-      nl + pad + "]";
-  }
+    if (v instanceof NovaRange)
+      return v.toString();
 
-  if (v instanceof NovaObject) {
-    const entries = Object.entries(v.inner);
+    if (v instanceof NovaStruct)
+      return v.toString();
 
-    if (!entries.length)
-      return "{}";
+    // ── Plain JS getter/setter descriptor { read, write } ────────────────────
+    // Scope variables with modifiers (tracked, lazy, clamp, etc.) are stored as
+    // plain objects with read() / write() functions.  Show the live value instead.
+    if (
+      v !== null && typeof v === 'object' &&
+      !(v instanceof NovaValue) && !(v instanceof NovaArray) &&
+      !(v instanceof NovaObject) && !(v instanceof NovaStruct) &&
+      !(v instanceof NovaEnum) && !(v instanceof Scope) &&
+      !(v instanceof Promise) && !Array.isArray(v) &&
+      typeof v.read === 'function' && typeof v.write === 'function'
+    ) {
+      return color.key + '[get/set ×]' + color.reset;
+    }
 
-    return "{\n" +
-      entries.map(([k, x]) =>
-        pad + "  " +
-        color.key + k + color.reset +
-        ": " +
-        next(x, indent + 1)
-      ).join(",\n") +
-      nl + pad + "}";
-  }
+    if (typeof v === "object" && v !== null) {
+      if (seen.has(v))
+        return color.circular + "[Circular]" + color.reset;
 
-  if (v instanceof NovaValue)
-    return v.toString();
+      seen.add(v);
+    }
 
-  if (v instanceof Scope)
-    return v.toString();
+    if (v instanceof NovaArray) {
+      if (!v.inner.length)
+        return "[]";
 
-  if (v && v.kind === "function")
-    return color.func +
-      `Function [${v.name || "anon"}]` +
-      color.reset;
+      return "[\n" +
+        v.inner.map(x =>
+          pad + "  " + next(x, indent + 1)
+        ).join(",\n") +
+        nl + pad + "]";
+    }
 
-  if (v && v.kind === "class")
-    return color.func +
-      `Class [${v.node?.name || "Unknown"}]` +
-      color.reset;
+    if (v instanceof NovaObject) {
+      // ── Build annotation badges ─────────────────────────────────────────────
+      const _annotations = [];
+
+      // Operator overloads stored under __operators
+      const _opsRaw = v.inner.__operators;
+      if (_opsRaw) {
+        const _opsObj = _opsRaw instanceof NovaObject
+          ? _opsRaw.inner
+          : (typeof _opsRaw === 'object' && _opsRaw !== null ? _opsRaw : {});
+        const _binOps = Object.keys(
+          _opsObj.binary instanceof NovaObject ? _opsObj.binary.inner : (_opsObj.binary || {})
+        );
+        const _unOps = Object.keys(
+          _opsObj.unary instanceof NovaObject ? _opsObj.unary.inner : (_opsObj.unary || {})
+        ).map(k => 'u' + k);
+        const _allOps = [..._binOps, ..._unOps];
+        _annotations.push('\x1b[33m[ops:' + (_allOps.length ? ' ' + _allOps.join(' ') : '') + ']\x1b[0m');
+      }
+
+      // Meta traps attached via attachMeta()
+      if (v._meta) {
+        const _traps = [];
+        if (typeof v._meta.get === 'function') _traps.push('get');
+        if (typeof v._meta.set === 'function') _traps.push('set');
+        if (typeof v._meta.missing === 'function') _traps.push('missing');
+        if (_traps.length) _annotations.push('\x1b[36m[meta:' + _traps.join(',') + ']\x1b[0m');
+      }
+
+      const _prefix = _annotations.length ? _annotations.join(' ') + ' ' : '';
+
+      // Hide internal plumbing keys from display
+      const _HIDE = new Set(['__operators']);
+      const _entries = Object.entries(v.inner).filter(([k]) => !_HIDE.has(k));
+
+      if (!_entries.length)
+        return _prefix + "{}";
+
+      return _prefix + "{\n" +
+        _entries.map(([k, x]) =>
+          pad + "  " +
+          color.key + k + color.reset +
+          ": " +
+          next(x, indent + 1)
+        ).join(",\n") +
+        nl + pad + "}";
+    }
 
-  if (v instanceof NovaEnum)
-    return v.toString();
+    if (v instanceof NovaValue)
+      return v.toString();
 
-  switch (typeof v) {
-    case "number":
-      return color.number +
-        (isNaN(v) ? "NaN" : String(v)) +
-        color.reset;
+    if (v instanceof Scope)
+      return v.toString();
 
-    case "string":
-      return color.string +
-        `"${v}"` +
+    if (v && v.kind === "function")
+      return color.func +
+        `Function [${v.name || "anon"}]` +
         color.reset;
 
-    case "boolean":
-      return color.bool +
-        String(v) +
+    if (v && v.kind === "class")
+      return color.func +
+        `Class [${v.node?.name || "Unknown"}]` +
         color.reset;
 
-    case "object": {
-      const entries = Object.entries(v);
-
-      if (!entries.length)
-        return "{}";
+    if (v instanceof NovaEnum)
+      return v.toString();
 
-      return "{\n" +
-        entries.map(([k, val]) =>
-          pad + "  " +
-          color.key + k + color.reset +
-          ": " +
-          next(val, indent + 1)
-        ).join(",\n") +
-        nl + pad + "}";
+    switch (typeof v) {
+      case "number":
+        return color.number +
+          (isNaN(v) ? "NaN" : String(v)) +
+          color.reset;
+
+      case "string":
+        return color.string +
+          `"${v}"` +
+          color.reset;
+
+      case "boolean":
+        return color.bool +
+          String(v) +
+          color.reset;
+
+      case "object": {
+        const entries = Object.entries(v);
+
+        if (!entries.length)
+          return "Native {}";
+
+        return "Native {\n" +
+          entries.map(([k, val]) =>
+            pad + "  " +
+            color.key + k + color.reset +
+            ": " +
+            next(val, indent + 1)
+          ).join(",\n") +
+          nl + pad + "}";
+      }
+
+      case "function":
+        return color.func +
+          `Function [${v.registered ? "Registered" : "NativeJs"}]` +
+          color.reset;
     }
 
-    case "function":
-      return color.func +
-        `Function [${v.registered ? "Registered" : "NativeJs"}]` +
-        color.reset;
+    return String(v);
   }
 
-  return String(v);
-}
-
   runFunctionNode(fn, scope, args = []) {
     if (!fn.execCount) fn.execCount = 0;
     fn.execCount++;
@@ -2788,12 +2941,20 @@ stringify(v, indent = 0, seen = new WeakSet()) {
           switch (current.type) {
             case 'if': {
               if (this.evaluate(current.args, scope)) {
-                this._runBodyWithYields(current.body, scope, collector);
+                const _sig = this._runBodyWithYields(current.body, scope, collector);
                 executed = true;
+                if (_sig === 'break') throw { __break: true };
+                if (_sig === 'continue') throw { __continue: true };
               } else current = current.next;
               break;
             }
-            case 'else': { this._runBodyWithYields(current.body, scope, collector); executed = true; break; }
+            case 'else': {
+              const _sig = this._runBodyWithYields(current.body, scope, collector);
+              executed = true;
+              if (_sig === 'break') throw { __break: true };
+              if (_sig === 'continue') throw { __continue: true };
+              break;
+            }
             case 'while': {
               const c = Array.isArray(current.args) ? current.args[0] : current.args;
               while (this.evaluate(c, scope)) {
@@ -2811,10 +2972,10 @@ stringify(v, indent = 0, seen = new WeakSet()) {
               executed = true; break;
             }
             default: {
-   	      try { this.execute(node, scope); }
+              try { this.execute(node, scope); }
               catch (e) { if (e && '__yield' in e) { collector.push(e.__yield); } else throw e; }
-                executed = true; break;
-              }
+              executed = true; break;
+            }
           }
         }
         return;
@@ -2985,7 +3146,8 @@ stringify(v, indent = 0, seen = new WeakSet()) {
       // ── declare ──
       case 'declare': {
         if (node.destructure) {
-          const val = this.evaluate(node.value, scope);
+          const evaled = this.evaluate(node.value, scope);
+          const val = evaled instanceof NovaObject ? evaled.inner : evaled;
           if (node.destructure.kind === 'objpattern') {
             for (const { key, alias, defaultValue } of node.destructure.props) {
               let v = val && Object.prototype.hasOwnProperty.call(val, key) ? val[key] : undefined;
@@ -3062,7 +3224,7 @@ stringify(v, indent = 0, seen = new WeakSet()) {
                   }
                   return false;
                 });
-                if (!ok) throw new Error("Variable '" + varName + "': value must be one of the declared union variants, got " + self._typeOf(v) + "("+v+")");
+                if (!ok) throw new Error("Variable '" + varName + "': value must be one of the declared union variants, got " + self._typeOf(v) + "(" + v + ")");
               }
             };
           }
@@ -3152,18 +3314,27 @@ stringify(v, indent = 0, seen = new WeakSet()) {
             case 'if': {
               if (this.evaluate(current.args, scope)) {
                 const bs = new Scope('block', scope, this.globalScope);
-                this.runLoop(current.body, bs); executed = true;
+                const _sig = this.runLoop(current.body, bs);
+                executed = true;
+                if (_sig === 'break') throw { __break: true };
+                if (_sig === 'continue') throw { __continue: true };
               } else current = current.next;
               break;
             }
             case 'else': {
               const bs = new Scope('block', scope, this.globalScope);
-              this.runLoop(current.body, bs); executed = true; break;
+              const _sig = this.runLoop(current.body, bs);
+              executed = true;
+              if (_sig === 'break') throw { __break: true };
+              if (_sig === 'continue') throw { __continue: true };
+              break;
             }
             case 'unless': {
               if (!this.evaluate(current.args, scope)) {
                 const bs = new Scope('block', scope, this.globalScope);
-                this.runLoop(current.body, bs);
+                const _sig = this.runLoop(current.body, bs);
+                if (_sig === 'break') throw { __break: true };
+                if (_sig === 'continue') throw { __continue: true };
               }
               executed = true; break;
             }
@@ -3290,7 +3461,7 @@ stringify(v, indent = 0, seen = new WeakSet()) {
         const val = node.value ? this.evaluate(node.value, scope) : undefined;
         for (const h of (this.eventBus.get(name) || [])) {
           if (h._native && typeof h._native === 'function') {
-            try { h._native(val); } catch (_) {}
+            try { h._native(val); } catch (_) { }
           } else {
             const hs = new Scope('function', scope, this.globalScope);
             if (h.param) hs.set(h.param, val);
@@ -3417,7 +3588,7 @@ stringify(v, indent = 0, seen = new WeakSet()) {
         return undefined;
       }
 
-       case 'import': {
+      case 'import': {
         const exports = this._loadModuleExports(node.source, scope);
         if (Array.isArray(node.names) && node.names.length > 0) {
           for (const name of node.names) scope.set(name, exports[name]);
@@ -3488,6 +3659,10 @@ stringify(v, indent = 0, seen = new WeakSet()) {
     switch (expr.kind) {
       case 'EOF': return undefined;
 
+      case 'regex_literal':
+        let pattern = this.evaluate(expr.pattern);
+        return new RegExp(typeof pattern === 'string' ? pattern : pattern.inner, expr.flags);
+
       case 'url_literal':
         return expr.value;
 
@@ -3500,7 +3675,7 @@ stringify(v, indent = 0, seen = new WeakSet()) {
       case 'fetch_expr': {
         const url = this.evaluate(expr.url, scope);
         const options = expr.options ? this.evaluate(expr.options, scope) : null;
-        return this._syncFetch(url, options);
+        return fetch(url, options);
       }
 
       case 'value': {
@@ -3517,7 +3692,7 @@ stringify(v, indent = 0, seen = new WeakSet()) {
 
       // ── Dynamic / meta variables ──────────────────────────────────────────
       case 'dvar': {
-        const _os  = require('os');
+        const _os = require('os');
         const _pth = require('path');
         const _cry = require('crypto');
         const dname = expr.name;
@@ -3728,11 +3903,11 @@ stringify(v, indent = 0, seen = new WeakSet()) {
             if (key === '__meta__' || (entry.key.kind === 'ref' && entry.key.name === 'method')) {
               metaDescriptor = this.evaluate(entry.value, scope);
             } else if (key === '__expr__' || (entry.key.kind === 'ref' && entry.key.name === 'expr')) {
-	       //detect [expr] key
- 	       obj['.expr'] = this.evaluate(entry.value, scope);
+              //detect [expr] key
+              obj['.expr'] = this.evaluate(entry.value, scope);
             } else if (key === '__op__' || (entry.key.kind === 'ref' && entry.key.name === 'op')) {
-	       //detect [operator] key
- 	       obj['__operators'] = this.evaluate(entry.value, scope);
+              //detect [operator] key
+              obj['__operators'] = this.evaluate(entry.value, scope);
             } else {
               obj[key] = this.evaluate(entry.value, scope);
             }
@@ -3804,7 +3979,7 @@ stringify(v, indent = 0, seen = new WeakSet()) {
       case 'assign': {
         const val = this.evaluate(expr.value, scope);
         let n = expr.name;
-        if (n.kind === 'dexpr') n = { name: this.evaluate(n.code, scope)  }
+        if (n.kind === 'dexpr') n = { name: this.evaluate(n.code, scope) }
         if (n.kind === 'deref') {
           const ptr = this.evaluate(n.operand, scope);
           if (!(ptr instanceof NovaPointer)) this.error('Deref non-pointer', expr);
@@ -3849,22 +4024,28 @@ stringify(v, indent = 0, seen = new WeakSet()) {
         ? this.evaluate(expr.consequent, scope) : this.evaluate(expr.alternate, scope);
 
       case 'if_ternary': {
-	let cond = this.evaluate(expr.cond, scope);
+        let cond = this.evaluate(expr.cond, scope);
         if (cond) { return this.evaluate(expr.operand, scope) }
         else if (expr.elseExpr) { return this.evaluate(expr.elseExpr, scope) }
       }
 
       case 'run_expr': return this.execute(expr.code, scope)
 
+      case 'native':
+	let val = this.evaluate(expr.value);
+        return val instanceof NovaValue ? val.inner : val;
+
+      case 'ast': return { kind:"ast", ast: expr.ast };
+
       case 'link': return {
         read: () => this.evaluate(expr.linked),
         write: (val) =>
-         this.evaluate({
-          kind: 'assign',
-          name: expr.linked,
-          value: { kind: 'value', value: val }
-         }, scope)
-       };
+          this.evaluate({
+            kind: 'assign',
+            name: expr.linked,
+            value: { kind: 'value', value: val }
+          }, scope)
+      };
 
       case 'dexpr': return this.evaluate(expr.code, scope);
 
@@ -3993,7 +4174,7 @@ stringify(v, indent = 0, seen = new WeakSet()) {
           const m = this._objectMethod(obj, pn);
           return m !== undefined ? m : null;
         }
-        if (!(Object.hasOwnProperty(obj, 'name'))) return (typeof expr.object.name === 'string') ? expr.object.name : 'anon';
+        if (!(Object.hasOwnProperty(obj, 'name')) && pn === 'name') return (typeof expr.object.name === 'string') ? expr.object.name : 'anon';
         return (obj != null ? obj[pn] : null);
       }
 
@@ -4188,7 +4369,7 @@ stringify(v, indent = 0, seen = new WeakSet()) {
               else if (obj instanceof Scope) obj.delete(o.name);
               else delete obj[o.name];
               return true;
-            }                                                                                                                                            if (o.kind === 'subscript') {
+            } if (o.kind === 'subscript') {
               const obj = this.evaluate(o.object, scope); const idx = this.evaluate(o.index, scope);
               if (obj instanceof NovaObject || obj instanceof NovaArray) obj.delete(idx);
               else if (obj instanceof Scope) obj.delete(idx);
@@ -4199,8 +4380,8 @@ stringify(v, indent = 0, seen = new WeakSet()) {
           }
         }
         let operand = this.evaluate(expr.operand, scope);
-	if (operand instanceof NovaObject) {
-	  let overload = operand?.get?.('__operators')?.get?.('unary')?.get?.(expr.operator);
+        if (operand instanceof NovaObject) {
+          let overload = operand?.get?.('__operators')?.get?.('unary')?.get?.(expr.operator);
           if (overload) return overload();
         }
         switch (expr.operator) {