novac 2.0.1 → 2.2.0

package/novac/src/core/nova_builtins.js

@@ -0,0 +1,717 @@
+/**
+ * Nova Built-in Class Objects
+ * ════════════════════════════
+ * Every statement in Nova has an equivalent OOP form.
+ * All registries are unified under the `nova` global object.
+ *
+ * Built-in constructable objects:
+ *   ForLoop, WhileLoop, UntilLoop, RepeatLoop, EachLoop,
+ *   IfBlock, MatchBlock, SwitchBlock,
+ *   TryCatch, Pipeline, FuncDef, EventBus,
+ *   Timer, Counter, Stack, Queue, LinkedList,
+ *   State, Struct, Enum, Range, Signal,
+ *   Lazy, Memo, Observable, Validator,
+ *   DataStream, Transformer, Router
+ */
+
+const { NovaArray, NovaObject, NovaRange, NovaStruct, NovaEnum, NovaBool, NovaNull } = require('./types');
+
+/** Unwrap NovaObject/NovaStruct to plain JS object for option spreading */
+function unwrapOpts(opts) {
+  if (!opts) return {};
+  if (opts instanceof NovaObject) return opts.inner;
+  if (opts instanceof NovaStruct)  return opts.inner;
+  if (typeof opts === 'object')    return opts;
+  return {};
+}
+
+// ═══════════════════════════════════════════════════════════
+//  Unified Registry — all Nova registries in one place
+// ═══════════════════════════════════════════════════════════
+function makeUnifiedRegistry(executor) {
+  const self = executor;
+
+  const registry = new NovaObject({});
+
+  // Live proxy that always reflects current state
+  const handler = {
+    get(target, prop) {
+      switch (prop) {
+        case 'macros':      return new NovaObject(Object.fromEntries(self.macros));
+        case 'blocks':      return new NovaObject(Object.fromEntries(self.blocks));
+        case 'snippets':    return new NovaObject(Object.fromEntries(self.snippets));
+        case 'gears':       return new NovaObject(Object.fromEntries(self.gears));
+        case 'sessions':    return new NovaObject(Object.fromEntries(self.sessions));
+        case 'resus':       return new NovaObject(Object.fromEntries(self.resus));
+        case 'keyfuncs':    return new NovaObject(Object.fromEntries(self.keyfuncs));
+        case 'backups':     return new NovaObject(Object.fromEntries(self.backups));
+        case 'options':     return new NovaObject({ ...self.options });
+        case 'descriptions':return new NovaArray([...self.descriptions]);
+        case 'types':       return makeTypeRegistryView(self.types);
+        case 'events':      return makeEventBusView(self.eventBus);
+        case 'scope':       return self.globalScope;
+        case 'version':     return '2.0';
+        // Kit metadata — { kitName: { meta, docs, provides, ... } }
+        case 'kitMeta':     return new NovaObject(self._kitMeta || {});
+        // Custom dynamic variables registered by kits — { name: fn }
+        case 'dvars':       return new NovaObject(Object.fromEntries(self._customDvars || new Map()));
+
+        // Registry mutation methods
+        case 'setMacro': return (name, val) => { self.macros.set(String(name), String(val)); self.globalScope.set(String(name), String(val)); };
+        case 'getMacro': return (name) => self.macros.get(String(name)) ?? null;
+        case 'hasMacro': return (name) => self.macros.has(String(name));
+
+        // Register a custom dynamic variable at runtime:
+        // nova.registerDvar('__myvar__', (scope, exe) => someValue)
+        case 'registerDvar': return (name, fn) => {
+          if (!self._customDvars) self._customDvars = new Map();
+          self._customDvars.set(String(name), fn);
+        };
+        case 'unregisterDvar': return (name) => {
+          if (self._customDvars) self._customDvars.delete(String(name));
+        };
+
+        case 'setBlock': return (name, fn) => { self.blocks.set(String(name), { body: [], _native: fn }); };
+        case 'runBlock': return (name) => {
+          const b = self.blocks.get(String(name));
+          if (!b) throw new Error('Block not found: ' + name);
+          if (b._native) return b._native();
+          return self.runLoop(b.body, b.scope || self.globalScope);
+        };
+
+        case 'runSnippet': return (name, ...args) => {
+          const s = self.snippets.get(String(name));
+          if (!s) throw new Error('Snippet not found: ' + name);
+          if (s._native) return s._native(...args);
+          return self.runLoop(s.body, s.scope || self.globalScope);
+        };
+
+        case 'emit':  return (event, val) => {
+          const handlers = self.eventBus.get(String(event)) || [];
+          for (const h of handlers) {
+            if (h._native && typeof h._native === 'function') {
+              try { h._native(val); } catch (_) {}
+            } else {
+              const hs = new (require('./executor').Scope)('function', self.globalScope, self.globalScope);
+              if (h.param) hs.set(h.param, val);
+              self.runLoop(h.body, hs);
+            }
+          }
+        };
+        case 'on': return (event, fn) => {
+          const name = String(event);
+          if (!self.eventBus.has(name)) self.eventBus.set(name, []);
+          self.eventBus.get(name).push({ param: '_v', body: [], _native: fn });
+        };
+
+        case 'eval': return (code) => {
+          const { Parser } = require('./parser');
+          const ast = new Parser(String(code)).parse();
+          return self.run(ast);
+        };
+
+        case 'inspect': return (name) => {
+          // Return everything about a name across all registries
+          return new NovaObject({
+            inScope:    self.globalScope.get(String(name)) != null,
+            isMacro:    self.macros.has(String(name)),
+            isBlock:    self.blocks.has(String(name)),
+            isSnippet:  self.snippets.has(String(name)),
+            isGear:     self.gears.has(String(name)),
+            isSession:  self.sessions.has(String(name)),
+            isResu:     self.resus.has(String(name)),
+            value:      self.globalScope.get(String(name)),
+          });
+        };
+
+        case 'clearAll': return () => {
+          self.macros.clear(); self.blocks.clear(); self.snippets.clear();
+          self.gears.clear(); self.sessions.clear(); self.descriptions.length = 0;
+        };
+
+        default:
+          // Try each registry in order
+          if (self.macros.has(prop))    return self.macros.get(prop);
+          if (self.blocks.has(prop))    return { run: () => self.runLoop(self.blocks.get(prop).body, self.blocks.get(prop).scope || self.globalScope) };
+          if (self.snippets.has(prop))  return self.snippets.get(prop);
+          if (self.gears.has(prop))     return self.gears.get(prop);
+          if (self.sessions.has(prop))  return self.sessions.get(prop);
+          if (self.resus.has(prop))     return self.resus.get(prop);
+          return target[prop] ?? null;
+      }
+    },
+    set(target, prop, value) {
+      // Write-through to appropriate registry
+      self.macros.set(String(prop), value);
+      self.globalScope.set(String(prop), value);
+      return true;
+    }
+  };
+
+  return new Proxy({}, handler);
+}
+
+function makeTypeRegistryView(types) {
+  return new NovaObject({
+    structs:    new NovaArray([...types.structs.keys()]),
+    interfaces: new NovaArray([...types.interfaces.keys()]),
+    enums:      new NovaArray([...types.enums.keys()]),
+    traits:     new NovaArray([...types.traits.keys()]),
+    check:      (val, typeName) => types.check(val, { kind: 'named_type', name: String(typeName) }),
+    list:       () => new NovaArray([
+      ...types.structs.keys(), ...types.interfaces.keys(),
+      ...types.enums.keys(), ...types.traits.keys()
+    ]),
+  });
+}
+
+function makeEventBusView(bus) {
+  return new NovaObject({
+    events:    () => new NovaArray([...bus.keys()]),
+    count:     (ev) => (bus.get(String(ev)) || []).length,
+    has:       (ev) => bus.has(String(ev)),
+    clear:     (ev) => bus.delete(String(ev)),
+    clearAll:  () => bus.clear(),
+  });
+}
+
+// ═══════════════════════════════════════════════════════════
+//  Built-in Class Objects — OOP alternatives to statement syntax
+// ═══════════════════════════════════════════════════════════
+
+/** ForLoop — OOP wrapper around for-loop logic */
+class NovaForLoop {
+  constructor(opts = {}) {
+    opts = unwrapOpts(opts);
+    this._from   = opts.from  ?? 0;
+    this._to     = opts.to    ?? 0;
+    this._step   = opts.step  ?? 1;
+    this._body   = opts.body  ?? null;
+    this._var    = opts.var   ?? 'i';
+    this._result = null;
+  }
+  from(n)  { this._from = n; return this; }
+  to(n)    { this._to   = n; return this; }
+  step(n)  { this._step = n; return this; }
+  do(fn)   { this._body = fn; return this; }
+  each(fn) { this._body = fn; return this; }
+  map(fn)  { this._body = fn; return this; }   // alias for do/each when collecting
+  // pipe() — convert to Pipeline for further transformation
+  pipe()   { return new NovaPipeline(this.toArray().inner); }
+  // toStream() — convert to DataStream
+  toStream() { return new NovaDataStream(this.toArray().inner); }
+  collect() {
+    const out = [];
+    for (let i = this._from; this._step > 0 ? i <= this._to : i >= this._to; i += this._step) {
+      out.push(this._body ? this._body(i) : i);
+    }
+    this._result = new NovaArray(out);
+    return this._result;
+  }
+  // For chained .map(...).collect() on a ForLoop:
+  // NovaForLoop supports being used as a Pipeline head
+  filter(fn) { return new NovaPipeline(this.toArray().inner).filter(fn); }
+  run() {
+    const fn = this._body;
+    for (let i = this._from; this._step > 0 ? i <= this._to : i >= this._to; i += this._step) {
+      if (fn) { try { fn(i); } catch(e) { if (e && '__break' in e) break; if (e && '__continue' in e) continue; throw e; } }
+    }
+    return this;
+  }
+  toRange() { return new NovaRange(this._from, this._to, this._step); }
+  toArray() {
+    const out = [];
+    for (let i = this._from; this._step > 0 ? i <= this._to : i >= this._to; i += this._step) out.push(i);
+    return new NovaArray(out);
+  }
+  toString() { return `ForLoop(${this._from}..${this._to} step ${this._step})`; }
+}
+
+/** WhileLoop */
+class NovaWhileLoop {
+  constructor(opts = {}) {
+    opts = unwrapOpts(opts);
+    this._cond = opts.cond ?? (() => false);
+    this._body = opts.body ?? null;
+    this._max  = opts.max  ?? Infinity;
+  }
+  cond(fn)   { this._cond = fn; return this; }
+  do(fn)     { this._body = fn; return this; }
+  maxIter(n) { this._max  = n; return this; }
+  run() {
+    let count = 0;
+    while (this._cond() && count++ < this._max) {
+      if (this._body) { try { this._body(count - 1); } catch(e) { if (e && '__break' in e) break; throw e; } }
+    }
+    return this;
+  }
+  toString() { return 'WhileLoop'; }
+}
+
+/** IfBlock */
+class NovaIfBlock {
+  constructor(opts = {}) {
+    opts = unwrapOpts(opts);
+    this._cond    = opts.cond  ?? false;
+    this._then    = opts.then  ?? null;
+    this._else    = opts.else  ?? null;
+    this._elseIfs = [];
+  }
+  cond(v)       { this._cond = v; return this; }
+  then(fn)      { this._then = fn; return this; }
+  else(fn)      { this._else = fn; return this; }
+  elseIf(c, fn) { this._elseIfs.push({ cond: c, fn }); return this; }
+  run() {
+    const c = typeof this._cond === 'function' ? this._cond() : this._cond;
+    if (c) { if (this._then) return this._then(); return true; }
+    for (const branch of this._elseIfs) {
+      const bc = typeof branch.cond === 'function' ? branch.cond() : branch.cond;
+      if (bc) { if (branch.fn) return branch.fn(); return true; }
+    }
+    if (this._else) return this._else();
+    return false;
+  }
+  toString() { return 'IfBlock'; }
+}
+
+/** TryCatch */
+class NovaTryCatch {
+  constructor(opts = {}) {
+    opts = unwrapOpts(opts);
+    this._try      = opts.try     ?? null;
+    this._catch    = opts.catch   ?? null;
+    this._finally  = opts.finally ?? null;
+    this._error    = null;
+    this._result   = undefined;
+  }
+  try(fn)     { this._try     = fn; return this; }
+  catch(fn)   { this._catch   = fn; return this; }
+  finally(fn) { this._finally = fn; return this; }
+  run() {
+    try {
+      if (this._try) this._result = this._try();
+    } catch(e) {
+      // Unwrap Nova exceptions to their payload value
+      const payload = (e && e.payload !== undefined) ? e.payload : e;
+      this._error = payload;
+      if (this._catch) this._result = this._catch(payload);
+    } finally {
+      if (this._finally) this._finally();
+    }
+    return this._result;
+  }
+  get error() { return this._error; }
+  toString() { return 'TryCatch'; }
+}
+
+/** Pipeline — functional composition chain */
+class NovaPipeline {
+  constructor(initial) {
+    this._val  = initial;
+    this._fns  = [];
+    this._name = null;
+  }
+  pipe(fn)     { this._fns.push({ fn, type: 'map' });    return this; }
+  filter(fn)   { this._fns.push({ fn, type: 'filter' }); return this; }
+  tap(fn)      { this._fns.push({ fn, type: 'tap' });    return this; }
+  map(fn)      { return this.pipe(fn); }
+  flatMap(fn)  { this._fns.push({ fn, type: 'flatMap'}); return this; }
+  reduce(fn, init) {
+    if (arguments.length === 0) { this._fns.push({ fn: null, type: 'reduce', init: undefined }); return this; }
+    if (typeof init !== 'undefined') {
+      // immediate reduce — collect then reduce
+      return this.collect().inner.reduce(fn, init);
+    }
+    this._fns.push({ fn, type: 'reduce', init }); return this;
+  }
+  take(n)      { this._fns.push({ n, type: 'take' }); return this; }
+  skip(n)      { this._fns.push({ n, type: 'skip' }); return this; }
+  named(n)     { this._name = n; return this; }
+  run(input) {
+    let val = input !== undefined ? input : this._val;
+    for (const step of this._fns) {
+      const arr = val instanceof NovaArray ? val.inner : (Array.isArray(val) ? val : null);
+      switch(step.type) {
+        case 'map':     val = arr ? new NovaArray(arr.map(step.fn)) : step.fn(val); break;
+        case 'filter':  val = arr ? new NovaArray(arr.filter(step.fn)) : (step.fn(val) ? val : null); break;
+        case 'tap':     step.fn(val); break;
+        case 'flatMap': val = arr ? new NovaArray(arr.flatMap(v => { const r = step.fn(v); return r instanceof NovaArray ? r.inner : [r]; })) : step.fn(val); break;
+        case 'reduce':  val = arr ? arr.reduce(step.fn, step.init) : step.fn(step.init, val); break;
+        case 'take':    val = arr ? new NovaArray(arr.slice(0, step.n)) : val; break;
+        case 'skip':    val = arr ? new NovaArray(arr.slice(step.n)) : val; break;
+      }
+    }
+    return val;
+  }
+  collect(input) { return this.run(input); }
+  toString() { return 'Pipeline[' + (this._name || this._fns.length + ' steps') + ']'; }
+}
+
+/** FuncDef — define and call functions dynamically */
+class NovaFuncDef {
+  constructor(opts = {}) {
+    opts = unwrapOpts(opts);
+    this._args = opts.args ?? [];
+    this._body = opts.body ?? null;
+    this._name = opts.name ?? 'anonymous';
+    this._executor = null;
+  }
+  args(...a)  { this._args = a.flat(); return this; }
+  body(fn)    { this._body = fn; return this; }
+  named(n)    { this._name = n; return this; }
+  call(...vals) {
+    if (typeof this._body === 'function') return this._body(...vals);
+    if (this._executor && this._body) {
+      const { Scope } = require('./executor');
+      const ls = new Scope('function', this._executor.globalScope, this._executor.globalScope);
+      this._args.forEach((a, i) => ls.set(a, vals[i]));
+      return this._executor.runFunctionNode({ args: this._args.map(n=>({name:n,rest:false,defaultValue:null})), body: this._body }, ls, vals);
+    }
+    return undefined;
+  }
+  toArrow() {
+    return (...args) => this.call(...args);
+  }
+  toString() { return `FuncDef[${this._name}(${this._args.join(',')})]`; }
+}
+
+/** Timer */
+class NovaTimer {
+  constructor() { this._start = null; this._laps = []; }
+  start()  { this._start = Date.now(); return this; }
+  stop()   { return Date.now() - (this._start ?? Date.now()); }
+  lap()    { const t = Date.now() - (this._start ?? Date.now()); this._laps.push(t); return t; }
+  reset()  { this._start = null; this._laps = []; return this; }
+  get elapsed() { return this._start ? Date.now() - this._start : 0; }
+  get laps()    { return new NovaArray(this._laps); }
+  toString() { return `Timer[${this.elapsed}ms]`; }
+}
+
+/** Counter */
+class NovaCounter {
+  constructor(initial = 0, step = 1) { this._val = initial; this._step = step; this._min = -Infinity; this._max = Infinity; }
+  increment(n) { this._val = Math.min(this._max, this._val + (n ?? this._step)); return this; }
+  decrement(n) { this._val = Math.max(this._min, this._val - (n ?? this._step)); return this; }
+  reset(v)     { this._val = v ?? 0; return this; }
+  clamp(lo,hi) { this._min = lo; this._max = hi; return this; }
+  get value()  { return this._val; }
+  toString()   { return `Counter[${this._val}]`; }
+}
+
+/** Stack */
+class NovaStack {
+  constructor(...initial) { this._data = [...initial]; }
+  push(...v)  { this._data.push(...v); return this; }
+  pop()       { return this._data.pop() ?? null; }
+  peek()      { return this._data[this._data.length - 1] ?? null; }
+  get size()  { return this._data.length; }
+  get empty() { return this._data.length === 0; }
+  clear()     { this._data = []; return this; }
+  toArray()   { return new NovaArray([...this._data]); }
+  toString()  { return `Stack[${this._data.length}]`; }
+}
+
+/** Queue */
+class NovaQueue {
+  constructor(...initial) { this._data = [...initial]; }
+  enqueue(...v) { this._data.push(...v); return this; }
+  dequeue()     { return this._data.shift() ?? null; }
+  peek()        { return this._data[0] ?? null; }
+  get size()    { return this._data.length; }
+  get empty()   { return this._data.length === 0; }
+  clear()       { this._data = []; return this; }
+  toArray()     { return new NovaArray([...this._data]); }
+  toString()    { return `Queue[${this._data.length}]`; }
+}
+
+/** LinkedList node */
+class LLNode { constructor(v){ this.value=v; this.next=null; } }
+/** LinkedList */
+class NovaLinkedList {
+  constructor() { this.head = null; this.tail = null; this._size = 0; }
+  push(v) {
+    const n = new LLNode(v);
+    if (!this.tail) { this.head = this.tail = n; } else { this.tail.next = n; this.tail = n; }
+    this._size++;
+    return this;
+  }
+  pop() {
+    if (!this.head) return null;
+    if (this.head === this.tail) { const v = this.head.value; this.head = this.tail = null; this._size--; return v; }
+    let cur = this.head;
+    while (cur.next !== this.tail) cur = cur.next;
+    const v = this.tail.value; cur.next = null; this.tail = cur; this._size--;
+    return v;
+  }
+  shift()   { if (!this.head) return null; const v = this.head.value; this.head = this.head.next; if (!this.head) this.tail = null; this._size--; return v; }
+  unshift(v){ const n = new LLNode(v); n.next = this.head; this.head = n; if (!this.tail) this.tail = n; this._size++; return this; }
+  find(fn)  { let cur = this.head; while (cur) { if (fn(cur.value)) return cur.value; cur = cur.next; } return null; }
+  toArray() { const out=[]; let cur=this.head; while(cur){out.push(cur.value);cur=cur.next;} return new NovaArray(out); }
+  get size(){ return this._size; }
+  toString(){ return `LinkedList[${this._size}]`; }
+}
+
+/** State machine */
+class NovaState {
+  constructor(initial) {
+    this._current    = initial ?? 'idle';
+    this._transitions = {};
+    this._onEnter    = {};
+    this._onExit     = {};
+    this._history    = [initial ?? 'idle'];
+  }
+  add(from, event, to) {
+    if (!this._transitions[from]) this._transitions[from] = {};
+    this._transitions[from][event] = to;
+    return this;
+  }
+  onEnter(state, fn) { this._onEnter[state] = fn; return this; }
+  onExit(state, fn)  { this._onExit[state]  = fn; return this; }
+  dispatch(event) {
+    const next = this._transitions[this._current]?.[event];
+    if (!next) return false;
+    if (this._onExit[this._current])  this._onExit[this._current](this._current);
+    this._current = next;
+    this._history.push(next);
+    if (this._onEnter[next]) this._onEnter[next](next);
+    return true;
+  }
+  get current() { return this._current; }
+  get history()  { return new NovaArray(this._history); }
+  is(state)      { return this._current === state; }
+  toString()     { return `State[${this._current}]`; }
+}
+
+/** Observable — reactive value with subscribers */
+class NovaObservable {
+  constructor(initial) { this._val = initial; this._subs = []; this._computed = []; }
+  get value() { return this._val; }
+  set value(v) { const old = this._val; this._val = v; this._subs.forEach(fn => fn(v, old)); this._computed.forEach(c => c._recompute()); }
+  subscribe(fn)   { this._subs.push(fn); return () => this._subs = this._subs.filter(s=>s!==fn); }
+  pipe(fn)        { const c = new NovaObservable(fn(this._val)); c._recompute = () => c.value = fn(this._val); this._computed.push(c); return c; }
+  once(fn)        { const unsub = this.subscribe((v,o) => { fn(v,o); unsub(); }); return this; }
+  toString()      { return `Observable[${this._val}]`; }
+}
+
+/** Validator */
+class NovaValidator {
+  constructor() { this._rules = []; }
+  required()                  { this._rules.push(v => v != null && v !== '' ? null : 'required'); return this; }
+  type(t)                     { this._rules.push(v => typeof v === t ? null : `expected ${t}`); return this; }
+  min(n)                      { this._rules.push(v => v >= n ? null : `min ${n}`); return this; }
+  max(n)                      { this._rules.push(v => v <= n ? null : `max ${n}`); return this; }
+  minLen(n)                   { this._rules.push(v => String(v).length >= n ? null : `minLen ${n}`); return this; }
+  maxLen(n)                   { this._rules.push(v => String(v).length <= n ? null : `maxLen ${n}`); return this; }
+  pattern(re)                 { this._rules.push(v => new RegExp(re).test(String(v)) ? null : `pattern ${re}`); return this; }
+  custom(fn, msg)             { this._rules.push(v => fn(v) ? null : (msg ?? 'invalid')); return this; }
+  email()                     { return this.pattern('[a-zA-Z0-9._%+\\-]+@[a-zA-Z0-9.\\-]+\\.[a-zA-Z]{2,}'); }
+  validate(v) {
+    const errors = this._rules.map(r => r(v)).filter(Boolean);
+    return new NovaObject({ valid: errors.length === 0, errors: new NovaArray(errors), value: v });
+  }
+  toString() { return `Validator[${this._rules.length} rules]`; }
+}
+
+/** DataStream — lazy collection with transformation */
+class NovaDataStream {
+  constructor(source) {
+    this._source = source instanceof NovaArray ? source.inner : (Array.isArray(source) ? source : [source]);
+    this._ops = [];
+  }
+  map(fn)        { this._ops.push({ type:'map',    fn }); return this; }
+  filter(fn)     { this._ops.push({ type:'filter', fn }); return this; }
+  take(n)        { this._ops.push({ type:'take',   n  }); return this; }
+  skip(n)        { this._ops.push({ type:'skip',   n  }); return this; }
+  flatMap(fn)    { this._ops.push({ type:'flatMap',fn }); return this; }
+  distinct()     { this._ops.push({ type:'distinct' });   return this; }
+  sort(fn)       { this._ops.push({ type:'sort',   fn }); return this; }
+  reverse()      { this._ops.push({ type:'reverse' });    return this; }
+  zip(other)     { this._ops.push({ type:'zip', other });  return this; }
+  collect() {
+    let data = [...this._source];
+    for (const op of this._ops) {
+      switch(op.type) {
+        case 'map':      data = data.map(op.fn); break;
+        case 'filter':   data = data.filter(op.fn); break;
+        case 'take':     data = data.slice(0, op.n); break;
+        case 'skip':     data = data.slice(op.n); break;
+        case 'flatMap':  data = data.flatMap(op.fn); break;
+        case 'distinct': data = [...new Set(data)]; break;
+        case 'sort':     data = [...data].sort(op.fn); break;
+        case 'reverse':  data = [...data].reverse(); break;
+        case 'zip': {
+          const other = op.other instanceof NovaArray ? op.other.inner : op.other;
+          const len = Math.min(data.length, other.length);
+          data = Array.from({length:len}, (_,i) => new NovaArray([data[i], other[i]]));
+          break;
+        }
+      }
+    }
+    return new NovaArray(data);
+  }
+  reduce(fn, init) { return this.collect().inner.reduce(fn, init); }
+  forEach(fn)      { this.collect().inner.forEach(fn); return this; }
+  first()          { return this.collect().inner[0] ?? null; }
+  last()           { const c = this.collect().inner; return c[c.length-1] ?? null; }
+  count()          { return this.collect().inner.length; }
+  toString()       { return `DataStream[${this._source.length} items, ${this._ops.length} ops]`; }
+}
+
+/** Transformer — bidirectional value transformation */
+class NovaTransformer {
+  constructor() { this._encode = []; this._decode = []; }
+  encode(fn) { this._encode.push(fn); return this; }
+  decode(fn) { this._decode.push(fn); return this; }
+  to(v)   { return this._encode.reduce((acc, fn) => fn(acc), v); }
+  from(v) { return this._decode.reduceRight((acc, fn) => fn(acc), v); }
+  // Preset transformers
+  static json()    {
+    const t = new NovaTransformer();
+    t.encode(v => JSON.stringify(v && v.inner !== undefined ? v.inner : v));
+    t.decode(v => JSON.parse(v));
+    return t;
+  }
+  static base64()  {
+    const t = new NovaTransformer();
+    t.encode(v => Buffer.from(String(v)).toString('base64'));
+    t.decode(v => Buffer.from(String(v), 'base64').toString('utf8'));
+    return t;
+  }
+  static upper()   { const t = new NovaTransformer(); t.encode(v => String(v).toUpperCase()); return t; }
+  static trim_()   { const t = new NovaTransformer(); t.encode(v => String(v).trim()); return t; }
+  static number_() { const t = new NovaTransformer(); t.encode(Number).decode(String); return t; }
+  toString() { return `Transformer[${this._encode.length}→${this._decode.length}]`; }
+}
+
+/** Router — simple pattern-matching router */
+class NovaRouter {
+  constructor() { this._routes = []; this._fallback = null; }
+  on(pattern, fn)   { this._routes.push({ pattern: new RegExp('^' + pattern + '$'), fn }); return this; }
+  default(fn)       { this._fallback = fn; return this; }
+  dispatch(path, ...args) {
+    for (const r of this._routes) {
+      const m = String(path).match(r.pattern);
+      if (m) return r.fn(...m.slice(1), ...args);
+    }
+    if (this._fallback) return this._fallback(path, ...args);
+    return null;
+  }
+  toString() { return `Router[${this._routes.length} routes]`; }
+}
+
+/** EventBus — standalone pub/sub */
+class NovaEventBus {
+  constructor() { this._handlers = {}; }
+  on(ev, fn)     { (this._handlers[ev] = this._handlers[ev]||[]).push(fn); return this; }
+  once(ev, fn)   { const wrap = (...a) => { fn(...a); this.off(ev, wrap); }; return this.on(ev, wrap); }
+  off(ev, fn)    { if (this._handlers[ev]) this._handlers[ev] = this._handlers[ev].filter(h=>h!==fn); return this; }
+  emit(ev, ...a) { (this._handlers[ev]||[]).forEach(fn => fn(...a)); return this; }
+  events()       { return new NovaArray(Object.keys(this._handlers)); }
+  toString()     { return `EventBus[${Object.keys(this._handlers).length} events]`; }
+}
+
+/** Memo — memoized function */
+class NovaMemo {
+  constructor(fn, keyFn) {
+    this._fn    = fn;
+    this._cache = new Map();
+    this._keyFn = keyFn ?? ((...a) => JSON.stringify(a));
+    this._hits  = 0; this._misses = 0;
+  }
+  call(...args) {
+    const key = this._keyFn(...args);
+    if (this._cache.has(key)) { this._hits++; return this._cache.get(key); }
+    this._misses++;
+    const result = this._fn(...args);
+    this._cache.set(key, result);
+    return result;
+  }
+  clear()      { this._cache.clear(); return this; }
+  invalidate(k){ this._cache.delete(this._keyFn(k)); return this; }
+  get stats()  { return new NovaObject({ hits: this._hits, misses: this._misses, size: this._cache.size }); }
+  toString()   { return `Memo[${this._cache.size} cached]`; }
+}
+
+/** Lazy — deferred evaluation */
+class NovaLazy {
+  constructor(fn) { this._fn = fn; this._val = undefined; this._evaluated = false; }
+  get value() { if (!this._evaluated) { this._val = this._fn(); this._evaluated = true; } return this._val; }
+  reset()     { this._evaluated = false; this._val = undefined; return this; }
+  force()     { return this.value; }
+  map(fn)     { return new NovaLazy(() => fn(this.value)); }
+  toString()  { return this._evaluated ? `Lazy[${this._val}]` : 'Lazy[?]'; }
+}
+
+/** Signal — reactive primitive (like a mini-observable) */
+class NovaSignal {
+  constructor(initial) { this._val = initial; this._effects = new Set(); }
+  get value()    { return this._val; }
+  set value(v)   { this._val = v; this._effects.forEach(fn => fn(v)); }
+  effect(fn)     { this._effects.add(fn); fn(this._val); return () => this._effects.delete(fn); }
+  derive(fn)     { const s = new NovaSignal(fn(this._val)); this.effect(v => s.value = fn(v)); return s; }
+  toString()     { return `Signal[${this._val}]`; }
+}
+
+/** MatchBlock — OOP pattern matching */
+class NovaMatchBlock {
+  constructor(subject) {
+    this._subject = subject;
+    this._cases   = [];
+    this._default = null;
+  }
+  when(pattern, fn) {
+    this._cases.push({ pattern, fn });
+    return this;
+  }
+  default(fn) { this._default = fn; return this; }
+  run() {
+    for (const c of this._cases) {
+      const p = c.pattern;
+      let match = false;
+      if (p instanceof NovaRange) match = p.includes(this._subject);
+      else if (typeof p === 'function') match = p(this._subject);
+      else if (Array.isArray(p) || p instanceof NovaArray) {
+        const arr = p instanceof NovaArray ? p.inner : p;
+        match = arr.some(v => v === this._subject);
+      }
+      else match = p === this._subject;
+      if (match) return c.fn(this._subject);
+    }
+    if (this._default) return this._default(this._subject);
+    return null;
+  }
+  toString() { return `MatchBlock[${this._cases.length} cases]`; }
+}
+
+// ═══════════════════════════════════════════════════════════
+//  Export
+// ═══════════════════════════════════════════════════════════
+module.exports = {
+  makeUnifiedRegistry,
+  // Statement-as-class exports
+  ForLoop:     (opts) => new NovaForLoop(opts||{}),
+  WhileLoop:   (opts) => new NovaWhileLoop(opts||{}),
+  IfBlock:     (opts) => new NovaIfBlock(opts||{}),
+  TryCatch:    (opts) => new NovaTryCatch(opts||{}),
+  Pipeline:    (v)    => new NovaPipeline(v),
+  FuncDef:     (opts) => new NovaFuncDef(opts||{}),
+  MatchBlock:  (v)    => new NovaMatchBlock(v),
+  // Data structures
+  Timer:       ()     => new NovaTimer(),
+  Counter:     (n,s)  => new NovaCounter(n,s),
+  Stack:       (...v) => new NovaStack(...v),
+  Queue:       (...v) => new NovaQueue(...v),
+  LinkedList:  ()     => new NovaLinkedList(),
+  State:       (s)    => new NovaState(s),
+  Observable:  (v)    => new NovaObservable(v),
+  Validator:   ()     => new NovaValidator(),
+  DataStream:  (s)    => new NovaDataStream(s),
+  Transformer: ()     => new NovaTransformer(),
+  TransformerJSON:    () => NovaTransformer.json(),
+  TransformerBase64:  () => NovaTransformer.base64(),
+  Router:      ()     => new NovaRouter(),
+  EventBus:    ()     => new NovaEventBus(),
+  Memo:        (fn,k) => new NovaMemo(fn,k),
+  Lazy:        (fn)   => new NovaLazy(fn),
+  Signal:      (v)    => new NovaSignal(v),
+};