novac 2.0.1 → 2.2.0

package/novac/src/core/bstd.js

@@ -0,0 +1,1035 @@
+const { CustomError, formatError, NovaException } = require('./error.js');
+const { hash } = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const readline = require('readline');
+const { execFileSync, execSync } = require('child_process');
+
+let Air = {};
+
+// read all .js files in the current directory
+fs.readdirSync(__dirname)
+  .filter(file => file !== 'bstd.js' && file.endsWith('.js'))
+  .forEach(file => {
+    const name = path.basename(file, '.js');
+    Air[name] = require(path.join(__dirname, file));
+  });
+
+let Chalk = require('chalk').default;
+
+// ─────────────────────────────────────────────────────────────────────────────
+//  History  (unchanged from original)
+// ─────────────────────────────────────────────────────────────────────────────
+let History = {
+  getKey(name) { return '.184.' + name; },
+  exists(key) { return fs.existsSync(key); },
+  createHistory(key) {
+    fs.writeFileSync(key, JSON.stringify({ history: [] }));
+    return key;
+  },
+  appendHistory(key, addition, pushOrIndex, index) {
+    let content = JSON.parse(fs.readFileSync(key));
+    if (pushOrIndex === 'index') content.history[index] = addition;
+    else content.history.push(addition);
+    fs.writeFileSync(key, JSON.stringify(content));
+  },
+  readHistory(key) {
+    let content = JSON.parse(fs.readFileSync(key));
+    return content.history;
+  },
+  rawSetHistory(key, historyArray) {
+    let content = JSON.parse(fs.readFileSync(key));
+    content.history = historyArray;
+    fs.writeFileSync(key, JSON.stringify(content));
+  },
+  rawGetHistory(key) {
+    let content = JSON.parse(fs.readFileSync(key));
+    return content.history;
+  },
+  clearHistory(key) {
+    fs.writeFileSync(key, JSON.stringify({ history: [] }));
+  }
+};
+
+// ─────────────────────────────────────────────────────────────────────────────
+//  Shema  (unchanged from original)
+// ─────────────────────────────────────────────────────────────────────────────
+const ShemaTypes = {};
+class ShemaType {
+  constructor(typename, validatorFunction, defaultObj) {
+    this.typename = typename;
+    this.validate = validatorFunction;
+    this.defaultObj
+    ShemaTypes[typename] = this;
+  }
+}
+class Shema {
+  constructor(obj) { this.shema = obj; }
+  validate(obj) {
+    for (const key in this.shema) {
+      const type = this.shema[key];
+      const value = obj[key];
+      if (type instanceof ShemaType) {
+        if (!type.validate(value))
+          throw new Error(`Validation failed for key "${key}": expected ${type.typename}, got ${typeof value}`);
+      } else if (type instanceof Shema) {
+        type.validate(value);
+      } else {
+        throw new Error(`Invalid shema definition for key "${key}"`);
+      }
+    }
+  }
+  defaultObj() {
+    const obj = {};
+    for (const key in this.shema) {
+      const type = this.shema[key];
+      if (type instanceof ShemaType) {
+        obj[key] = type.typename === 'Int' || type.typename === 'Float' ? 0 :
+          type.typename === 'String' ? '' :
+            type.typename === 'Boolean' ? false :
+              type.typename === 'Array' ? [] :
+                type.typename === 'Object' ? {} :
+                  type.typename === 'Function' ? () => { } :
+                    type.typename === 'Null' ? null :
+                      type.typename === 'Undefined' ? undefined : 
+                       type?.defaultObj ? type.defaultObj() : null;
+      } else if (type instanceof Shema) {
+        obj[key] = type.defaultObj();
+      } else {
+        throw new Error(`Invalid shema definition for key "${key}"`);
+      }
+    }
+    return obj;
+  }
+}
+new ShemaType('Int', v => Number.isInteger(v));
+new ShemaType('Float', v => typeof v === 'number' && !Number.isNaN(v));
+new ShemaType('String', v => typeof v === 'string');
+new ShemaType('Boolean', v => typeof v === 'boolean');
+new ShemaType('Array', v => Array.isArray(v));
+new ShemaType('Object', v => v !== null && typeof v === 'object' && !Array.isArray(v));
+new ShemaType('Function', v => typeof v === 'function');
+new ShemaType('Null', v => v === null);
+new ShemaType('Undefined', v => v === undefined);
+new ShemaType('Symbol', v => typeof v === 'symbol');
+new ShemaType('BigInt', v => typeof v === 'bigint');
+new ShemaType('Date', v => v instanceof Date && !isNaN(v));
+new ShemaType('RegExp', v => v instanceof RegExp);
+new ShemaType('Shema', v => v instanceof Shema);
+new ShemaType('Any', () => true);
+
+// ─────────────────────────────────────────────────────────────────────────────
+//  ConfigFile  (unchanged from original)
+// ─────────────────────────────────────────────────────────────────────────────
+class ConfigFile {
+  constructor(name, type, hiddenFile = false, shema) {
+    this.path = hiddenFile ? '.134.' + name + '.' + type : name + '.135.' + type;
+    this.type = type;
+    this.shema = shema instanceof Shema ? shema : null;
+    if (!fs.existsSync(this.path))
+      fs.writeFileSync(this.path, this.type === 'json' ? JSON.parse(shema.defaultObj) : '');
+  }
+  writeFull(configObj) {
+    if (this.shema && this.shema instanceof Shema && this.shema.validate(configObj) === false)
+      throw new Error('Config validation failed');
+    fs.writeFileSync(this.path, JSON.stringify(configObj));
+  }
+  write(key, value) {
+    const config = this.readFull();
+    let current = config;
+    for (let i = 0; i < key.length - 1; i++) {
+      if (typeof current[key[i]] !== 'object' || current[key[i]] === null) current[key[i]] = {};
+      current = current[key[i]];
+    }
+    current[key[key.length - 1]] = value;
+    this.writeFull(config);
+  }
+  readFull() {
+    const content = fs.readFileSync(this.path, 'utf-8');
+    if (this.type === 'json') return JSON.parse(content);
+    throw new Error('Unsupported config type: ' + this.type);
+  }
+  read(key) {
+    const config = this.readFull();
+    let current = config;
+    for (let i = 0; i < key.length; i++) {
+      if (typeof current[key[i]] !== 'object' || current[key[i]] === null) return undefined;
+      current = current[key[i]];
+    }
+    return current;
+  }
+  interactiveSetup(defaultConfig = {}) {
+    const config = this.readFull();
+    const mergedConfig = { ...defaultConfig, ...config };
+    const questions = [];
+    const buildQuestions = (obj, path = []) => {
+      for (const key in obj) {
+        const value = obj[key];
+        if (typeof value === 'object' && value !== null) buildQuestions(value, path.concat(key));
+        else questions.push({ path: path.concat(key), default: value });
+      }
+    };
+    buildQuestions(mergedConfig);
+    const askQuestion = (index) => {
+      if (index >= questions.length) { this.writeFull(mergedConfig); console.log('Config saved successfully!'); return; }
+      const { path, default: defaultValue } = questions[index];
+      InputMgr.prompt(`Enter value for ${path.join('.')} (default: ${defaultValue}): `).then(answer => {
+        if (answer.trim() !== '') {
+          let current = mergedConfig;
+          for (let i = 0; i < path.length - 1; i++) {
+            if (typeof current[path[i]] !== 'object' || current[path[i]] === null) current[path[i]] = {};
+            current = current[path[i]];
+          }
+          current[path[path.length - 1]] = answer;
+        }
+        askQuestion(index + 1);
+      });
+    };
+    askQuestion(0);
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+//  JsDB / Storage / Zip / Crypto / PathUtils / Base64 / OsUtils  (unchanged)
+// ─────────────────────────────────────────────────────────────────────────────
+let JsDB = {
+  class(JsClass) { return (...args) => new JsClass(...args); },
+  run(code) { return eval(code); },
+  require: (p) => require(path.join(process.cwd(), p)),
+  reqRaw: require,
+  gt: globalThis,
+  fetch(url, options) {
+    const { execSync } = require('child_process');
+    let command;
+    if (process.platform === 'win32') {
+      command = `powershell -Command "Invoke-WebRequest -Uri '${url}' -Method ${options?.method || 'GET'} -Headers @(${Object.entries(options?.headers || {}).map(([k, v]) => `@{${k}='${v}'}`).join(',')}) -Body '${options?.body || ''}' -UseBasicParsing"`;
+    } else {
+      command = `curl -X ${options?.method || 'GET'} '${url}' ${Object.entries(options?.headers || {}).map(([k, v]) => `-H "${k}: ${v}"`).join(' ')} -d '${options?.body || ''}'`;
+    }
+    try { return execSync(command, { encoding: 'utf-8' }); }
+    catch (error) { throw new Error(`Fetch failed: ${error.message}`); }
+  },
+  process,
+  version: process.version,
+  platform: process.platform,
+  env: process.env
+};
+
+const Storage = {
+  setItem(key, value) {
+    const filePath = path.join(__dirname, '.storage', key);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, JSON.stringify(value));
+  },
+  getItem(key) {
+    const filePath = path.join(__dirname, '.storage', key);
+    if (fs.existsSync(filePath)) return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    return null;
+  },
+  removeItem(key) {
+    const filePath = path.join(__dirname, '.storage', key);
+    if (fs.existsSync(filePath)) fs.unlinkSync(filePath);
+  },
+  clear() {
+    const storageDir = path.join(__dirname, '.storage');
+    if (fs.existsSync(storageDir)) fs.rmSync(storageDir, { recursive: true, force: true });
+  }
+};
+
+const Zip = {
+  zip(files, output) {
+    const archiver = require('archiver');
+    const outputStream = fs.createWriteStream(output);
+    const archive = archiver('zip', { zlib: { level: 9 } });
+    return new Promise((resolve, reject) => {
+      outputStream.on('close', () => resolve());
+      archive.on('error', err => reject(err));
+      archive.pipe(outputStream);
+      files.forEach(file => { if (fs.existsSync(file)) archive.file(file, { name: path.basename(file) }); });
+      archive.finalize();
+    });
+  },
+  unzip(zipFile, outputDir) {
+    const unzipper = require('unzipper');
+    return new Promise((resolve, reject) => {
+      fs.createReadStream(zipFile)
+        .pipe(unzipper.Extract({ path: outputDir }))
+        .on('close', () => resolve())
+        .on('error', err => reject(err));
+    });
+  }
+};
+
+const Crypto = {
+  hash(data, algorithm = 'sha256') { return hash(algorithm).update(data).digest('hex'); }
+};
+
+const PathUtils = {
+  join(...segments) { return path.join(...segments); },
+  resolve(...segments) { return path.resolve(...segments); },
+  basename(p, ext) { return path.basename(p, ext); },
+  dirname(p) { return path.dirname(p); },
+  extname(p) { return path.extname(p); }
+};
+
+const Base64 = {
+  encode(str) { return Buffer.from(str, 'utf-8').toString('base64'); },
+  decode(encoded) { return Buffer.from(encoded, 'base64').toString('utf-8'); }
+};
+
+const OsUtils = {
+  platform: process.platform,
+  homedir: require('os').homedir,
+  tmpdir: require('os').tmpdir,
+  cpus: require('os').cpus,
+  totalmem: require('os').totalmem,
+  freemem: require('os').freemem,
+  uptime: require('os').uptime
+};
+switch (process.platform) {
+  case 'win32':
+    OsUtils.requestAdminPrivileges = function () {
+      try { execSync('powershell -Command "Start-Process cmd -Verb runAs"'); }
+      catch (error) { throw new Error('Failed to request admin privileges: ' + error.message); }
+    };
+    OsUtils.openFile = function (filePath) {
+      try { execSync(`start "" "${filePath}"`); }
+      catch (error) { throw new Error('Failed to open file: ' + error.message); }
+    };
+    break;
+  case 'darwin':
+    OsUtils.openFile = function (filePath) {
+      try { execSync(`open "${filePath}"`); }
+      catch (error) { throw new Error('Failed to open file: ' + error.message); }
+    };
+    break;
+  case 'linux':
+    OsUtils.openFile = function (filePath) {
+      try { execSync(`xdg-open "${filePath}"`); }
+      catch (error) { throw new Error('Failed to open file: ' + error.message); }
+    };
+    break;
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+//  MathExprDebugger  (unchanged from original)
+// ─────────────────────────────────────────────────────────────────────────────
+class MathExprDebugger {
+  constructor(value) { this.value = value.toString(); }
+  __operators = {
+    unary: {
+      '+': () => new MathExprDebugger(this.value),
+      '-': () => new MathExprDebugger('( -' + this.value + ' )')
+    },
+    binary: {
+      '+': (a) => new MathExprDebugger(`(${this.value} + ${a.value})`),
+      '-': (a) => new MathExprDebugger(`(${this.value} - ${a.value})`),
+      '*': (a) => new MathExprDebugger(`(${this.value} * ${a.value})`),
+      '/': (a) => new MathExprDebugger(`(${this.value} / ${a.value})`)
+    }
+  };
+  toString() { return this.value; }
+}
+
+// ═════════════════════════════════════════════════════════════════════════════
+//
+//   I N P U T M G R   —   Full terminal input manager for novac / bstd
+//
+//   Features:
+//     · prompt(msg, opts)          — sync line read  (main API)
+//     · promptAsync(msg, opts)     — async line read
+//     · promptPassword(msg)        — sync  masked/hashed password read
+//     · promptPasswordAsync(msg)   — async masked/hashed password read
+//     · repl(opts)                 — sync  REPL loop
+//     · replAsync(opts)            — async REPL loop
+//     · mouse(cb, opts)            — terminal mouse/click event listener (async)
+//     · SyntaxHighlight            — pluggable syntax highlight API
+//     · history management         — per-name persistent JSON history files
+//
+// ═════════════════════════════════════════════════════════════════════════════
+
+// ── ANSI helpers ─────────────────────────────────────────────────────────────
+const ESC = '\x1b';
+const _ansi = {
+  reset: `${ESC}[0m`,
+  bold: `${ESC}[1m`,
+  dim: `${ESC}[2m`,
+  hide: `${ESC}[?25l`,
+  show: `${ESC}[?25h`,
+  clearLine: `${ESC}[2K`,
+  bol: `${ESC}[0G`,
+  up: (n = 1) => `${ESC}[${n}A`,
+  down: (n = 1) => `${ESC}[${n}B`,
+  right: (n = 1) => `${ESC}[${n}C`,
+  left: (n = 1) => `${ESC}[${n}D`,
+  col: (n) => `${ESC}[${n}G`,
+  mouseOn: `${ESC}[?1000h${ESC}[?1002h${ESC}[?1006h`,
+  mouseOff: `${ESC}[?1006l${ESC}[?1002l${ESC}[?1000l`,
+  fg: (c) => `${ESC}[${c}m`,
+  saveCursor: `${ESC}[s`,
+  restCursor: `${ESC}[u`,
+};
+
+// ── syncReadLine — the core synchronous stdin line reader ─────────────────────
+// Reads one line from stdin in raw mode, honouring:
+//   mask        — character to echo instead of real chars (password mode)
+//   history     — array of previous entries for ↑/↓ navigation
+//   highlight   — function(line) → coloured string for display
+//   placeholder — greyed-out text shown when buffer is empty
+function _syncReadLine(promptStr, { mask = null, history = [], highlight = null, placeholder = '' } = {}) {
+  const stdin = process.stdin;
+  const stdout = process.stdout;
+
+  // Save / restore terminal settings
+  const wasTTY = stdin.isTTY;
+  const wasRaw = wasTTY && stdin.isRaw;
+
+  if (wasTTY) stdin.setRawMode(true);
+  stdin.resume();
+
+  let buf = '';
+  let cursor = 0;           // insertion point in buf
+  let histIdx = history.length; // pointer: history.length = "current" (fresh) line
+  let saved = '';           // preserves current input when navigating history
+
+  // Write prompt + current buffer, clear to end of line
+  const redraw = () => {
+    const display = mask
+      ? mask.repeat(buf.length)
+      : (highlight ? highlight(buf) : buf);
+    const shown = buf.length === 0 && placeholder
+      ? `${_ansi.dim}${placeholder}${_ansi.reset}`
+      : display;
+    // Go to BOL, clear line, rewrite
+    stdout.write(`\r${_ansi.clearLine}${promptStr}${shown}`);
+    // Reposition cursor
+    const visLen = (mask ? mask.length * cursor : promptStr.length + cursor);
+    // We know promptStr printable length is promptStr.replace(/\x1b\[[^m]*m/g,'').length
+    const promptVis = promptStr.replace(/\x1b\[[^m]*m/g, '').length;
+    stdout.write(_ansi.col(promptVis + cursor + 1));
+  };
+
+  redraw();
+
+  let line = null;
+  // Read bytes synchronously in a tight loop
+  const buf8 = Buffer.alloc(8);
+
+  while (line === null) {
+    const n = fs.readSync(stdin.fd, buf8, 0, buf8.length, null);
+    if (n <= 0) { line = buf; break; }
+    let seq = buf8.slice(0, n).toString('utf8');
+
+    // ── Escape sequences ───────────────────────────────────────────────────
+    if (seq === '\x1b[A' || seq === '\x1bOA') {
+      // Arrow UP — history prev
+      if (histIdx > 0) {
+        if (histIdx === history.length) saved = buf;
+        histIdx--;
+        buf = history[histIdx];
+        cursor = buf.length;
+        redraw();
+      }
+      continue;
+    }
+    if (seq === '\x1b[B' || seq === '\x1bOB') {
+      // Arrow DOWN — history next
+      if (histIdx < history.length) {
+        histIdx++;
+        buf = histIdx === history.length ? saved : history[histIdx];
+        cursor = buf.length;
+        redraw();
+      }
+      continue;
+    }
+    if (seq === '\x1b[C' || seq === '\x1bOC') {
+      // Arrow RIGHT
+      if (cursor < buf.length) { cursor++; redraw(); }
+      continue;
+    }
+    if (seq === '\x1b[D' || seq === '\x1bOD') {
+      // Arrow LEFT
+      if (cursor > 0) { cursor--; redraw(); }
+      continue;
+    }
+    if (seq === '\x1b[H' || seq === '\x1bOH' || seq === '\x01') {
+      // Home / Ctrl-A
+      cursor = 0; redraw(); continue;
+    }
+    if (seq === '\x1b[F' || seq === '\x1bOF' || seq === '\x05') {
+      // End / Ctrl-E
+      cursor = buf.length; redraw(); continue;
+    }
+    if (seq === '\x1b[3~') {
+      // Delete key
+      if (cursor < buf.length) { buf = buf.slice(0, cursor) + buf.slice(cursor + 1); redraw(); }
+      continue;
+    }
+    // Ctrl-U — clear line
+    if (seq === '\x15') { buf = ''; cursor = 0; redraw(); continue; }
+    // Ctrl-K — clear from cursor to end
+    if (seq === '\x0b') { buf = buf.slice(0, cursor); redraw(); continue; }
+    // Ctrl-W — delete word before cursor
+    if (seq === '\x17') {
+      const left = buf.slice(0, cursor).replace(/\S+\s*$/, '');
+      buf = left + buf.slice(cursor);
+      cursor = left.length;
+      redraw(); continue;
+    }
+
+    // ── Single characters ──────────────────────────────────────────────────
+    for (let i = 0; i < seq.length; i++) {
+      const ch = seq[i];
+      const code = ch.charCodeAt(0);
+
+      if (ch === '\r' || ch === '\n') {
+        // Enter
+        stdout.write('\n');
+        line = buf;
+        break;
+      }
+      if (code === 127 || code === 8) {
+        // Backspace
+        if (cursor > 0) { buf = buf.slice(0, cursor - 1) + buf.slice(cursor); cursor--; redraw(); }
+        continue;
+      }
+      if (ch === '\x03') {
+        // Ctrl-C
+        stdout.write('^C\n');
+        if (wasTTY) stdin.setRawMode(wasRaw);
+        stdin.pause();
+        process.exit(130);
+      }
+      if (ch === '\x04') {
+        // Ctrl-D (EOF)
+        stdout.write('\n');
+        line = buf;
+        break;
+      }
+      if (code >= 32) {
+        // Printable
+        buf = buf.slice(0, cursor) + ch + buf.slice(cursor);
+        cursor++;
+        redraw();
+      }
+    }
+  }
+
+  if (wasTTY) stdin.setRawMode(wasRaw);
+  stdin.pause();
+
+  return line;
+}
+
+// ── SyntaxHighlight — pluggable highlighter registry ─────────────────────────
+//
+// Usage:
+//   SyntaxHighlight.register('myLang', (line) => coloredLine);
+//   const hl = SyntaxHighlight.get('myLang');
+//   SyntaxHighlight.highlight('myLang', 'some code');
+//
+// Built-in themes: 'novac', 'json', 'shell', 'basic', 'bf'
+const SyntaxHighlight = (() => {
+  const _reg = new Map();
+
+  // ── colour helpers (no deps) ────────────────────────────────────────────
+  const C = {
+    reset: '\x1b[0m',
+    keyword: '\x1b[35m',   // magenta
+    string: '\x1b[32m',   // green
+    number: '\x1b[33m',   // yellow
+    comment: '\x1b[90m',   // dark grey
+    ident: '\x1b[36m',   // cyan
+    op: '\x1b[37m',   // white
+    error: '\x1b[31m',   // red
+    prompt: '\x1b[94m',   // bright blue
+    dim: '\x1b[2m',
+    bold: '\x1b[1m',
+  };
+
+  // paint helper: wrap text in a colour and reset
+  const paint = (colour, text) => colour + text + C.reset;
+
+  // ── Nova/novac highlighter ──────────────────────────────────────────────
+  const _novacKeywords = new Set([
+    'var', 'let', 'const', 'class', 'if', 'else', 'for', 'while', 'do', 'return', 'give',
+    'func', 'function', 'async', 'await', 'new', 'import', 'export', 'from', 'switch',
+    'case', 'default', 'break', 'continue', 'try', 'catch', 'finally', 'throw', 'emit',
+    'on', 'of', 'each', 'match', 'when', 'where', 'as', 'type', 'struct', 'interface',
+    'enum', 'trait', 'impl', 'yield', 'loop', 'repeat', 'unless', 'until', 'block',
+    'assert', 'guard', 'with', 'run', 'true', 'false', 'null',
+  ]);
+
+  const _hlNovac = (line) => {
+    // Tokenise very simply: strings, numbers, keywords, idents, operators
+    let out = '';
+    let i = 0;
+    while (i < line.length) {
+      // Comment
+      if (line[i] === '/' && (line[i + 1] === '/' || line[i + 1] === '!')) {
+        out += paint(C.comment, line.slice(i)); break;
+      }
+      // String (single or double)
+      if (line[i] === '"' || line[i] === "'") {
+        const q = line[i]; let j = i + 1;
+        while (j < line.length && line[j] !== q) { if (line[j] === '\\') j++; j++; }
+        out += paint(C.string, line.slice(i, j + 1)); i = j + 1; continue;
+      }
+      // f-string prefix
+      if (line[i] === 'f' && (line[i + 1] === '"' || line[i + 1] === "'")) {
+        const q = line[i + 1]; let j = i + 2;
+        while (j < line.length && line[j] !== q) { if (line[j] === '\\') j++; j++; }
+        out += paint(C.string, line.slice(i, j + 1)); i = j + 1; continue;
+      }
+      // Number
+      if (/[0-9]/.test(line[i])) {
+        let j = i;
+        while (j < line.length && /[0-9._xXbBoOeE+\-]/.test(line[j])) j++;
+        out += paint(C.number, line.slice(i, j)); i = j; continue;
+      }
+      // Identifier / keyword
+      if (/[A-Za-z_$]/.test(line[i])) {
+        let j = i;
+        while (j < line.length && /[A-Za-z0-9_$]/.test(line[j])) j++;
+        const word = line.slice(i, j);
+        out += _novacKeywords.has(word) ? paint(C.keyword, word) : paint(C.ident, word);
+        i = j; continue;
+      }
+      // Operators & punctuation — keep plain
+      out += paint(C.op, line[i]); i++;
+    }
+    return out;
+  };
+
+  // ── JSON highlighter ────────────────────────────────────────────────────
+  const _hlJSON = (line) => {
+    return line
+      .replace(/"(?:[^"\\]|\\.)*"/g, s => paint(C.string, s))
+      .replace(/\b(-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)\b/g, s => paint(C.number, s))
+      .replace(/\b(true|false|null)\b/g, s => paint(C.keyword, s));
+  };
+
+  // ── Shell highlighter ───────────────────────────────────────────────────
+  const _shellKw = new Set(['if', 'then', 'else', 'fi', 'for', 'do', 'done', 'while', 'case', 'esac', 'function', 'return', 'exit', 'echo', 'cd', 'ls', 'mkdir', 'rm', 'cp', 'mv', 'grep', 'sed', 'awk', 'cat', 'source', 'export', 'alias']);
+  const _hlShell = (line) => {
+    if (line.trimStart().startsWith('#')) return paint(C.comment, line);
+    let out = '';
+    const tokens = line.split(/(\s+|[|>&;(){}[\]]|"(?:[^"\\]|\\.)*"|'[^']*')/);
+    let first = true;
+    for (const tok of tokens) {
+      if (!tok) continue;
+      if (first && /[A-Za-z_]/.test(tok[0])) {
+        out += _shellKw.has(tok) ? paint(C.keyword, tok) : paint(C.prompt, tok);
+        first = false;
+      } else if (tok.startsWith('"') || tok.startsWith("'")) {
+        out += paint(C.string, tok);
+      } else if (/^-?[0-9]+$/.test(tok)) {
+        out += paint(C.number, tok);
+      } else if (/^[|>&;(){}[\]]$/.test(tok.trim())) {
+        out += paint(C.op, tok);
+      } else {
+        out += tok;
+      }
+    }
+    return out;
+  };
+
+  // ── BASIC highlighter ───────────────────────────────────────────────────
+  const _basicKw = new Set([
+    'PRINT', 'INPUT', 'LET', 'IF', 'THEN', 'ELSE', 'GOTO', 'GOSUB', 'RETURN', 'END',
+    'FOR', 'TO', 'STEP', 'NEXT', 'DIM', 'DATA', 'READ', 'RESTORE', 'REM', 'STOP',
+    'LIST', 'RUN', 'NEW', 'LOAD', 'SAVE', 'CLS', 'CLR', 'AND', 'OR', 'NOT',
+    'INT', 'SQR', 'ABS', 'RND', 'SIN', 'COS', 'TAN', 'LOG', 'EXP', 'SGN',
+    'MID$', 'LEFT$', 'RIGHT$', 'LEN', 'STR$', 'VAL', 'CHR$', 'ASC', 'INSTR',
+    'TAB', 'SPC', 'AT', 'POKE', 'PEEK', 'CALL', 'ON',
+  ]);
+  const _hlBasic = (line) => {
+    // line-number prefix
+    const lineNo = line.match(/^(\s*\d+\s)/);
+    let rest = lineNo ? line.slice(lineNo[0].length) : line;
+    let prefix = lineNo ? paint(C.number, lineNo[0]) : '';
+    // REM comment
+    if (/^\s*REM\b/i.test(rest)) return prefix + paint(C.comment, rest);
+    let out = '';
+    const tokens = rest.split(/(\b[A-Z$]+\b|\d+(?:\.\d+)?|"[^"]*"|[^A-Za-z0-9"$\s]+|\s+)/gi);
+    for (const tok of tokens) {
+      if (!tok) continue;
+      if (_basicKw.has(tok.toUpperCase())) out += paint(C.keyword, tok);
+      else if (tok.startsWith('"')) out += paint(C.string, tok);
+      else if (/^-?\d/.test(tok)) out += paint(C.number, tok);
+      else out += tok;
+    }
+    return prefix + out;
+  };
+
+  // ── Brainfuck highlighter ───────────────────────────────────────────────
+  const _hlBF = (line) => {
+    return [...line].map(c => {
+      if ('><'.includes(c)) return paint(C.ident, c);
+      if ('+-'.includes(c)) return paint(C.keyword, c);
+      if ('.,'.includes(c)) return paint(C.string, c);
+      if ('[]'.includes(c)) return paint(C.op, c);
+      return paint(C.comment, c);
+    }).join('');
+  };
+
+  // Register built-ins
+  _reg.set('novac', _hlNovac);
+  _reg.set('nova', _hlNovac);
+  _reg.set('json', _hlJSON);
+  _reg.set('shell', _hlShell);
+  _reg.set('bash', _hlShell);
+  _reg.set('basic', _hlBasic);
+  _reg.set('bf', _hlBF);
+
+  return {
+    /** Register a custom highlighter: fn(line: string) → string */
+    register(name, fn) { _reg.set(name, fn); },
+    /** Get a highlighter by name (or null) */
+    get(name) { return _reg.get(name) || null; },
+    /** Highlight a line with a named theme */
+    highlight(name, line) {
+      const fn = _reg.get(name);
+      return fn ? fn(line) : line;
+    },
+    /** List registered theme names */
+    list() { return [..._reg.keys()]; },
+    /** Raw colour constants for custom highlighters */
+    colors: C,
+    paint,
+  };
+})();
+
+// ── InputMgr — main export ────────────────────────────────────────────────────
+const InputMgr = (() => {
+
+  // ── internal history manager ──────────────────────────────────────────────
+  //
+  // Histories are stored in hidden JSON files: `.184.<name>`
+  // The same format used by the existing `History` object in bstd, but
+  // InputMgr manages them automatically per prompt name.
+  //
+  const _histCache = new Map(); // name → array of strings (in-memory)
+
+  function _histKey(name) { return '.184.inputmgr.' + name; }
+
+  function _histLoad(name) {
+    if (_histCache.has(name)) return _histCache.get(name);
+    const key = _histKey(name);
+    let arr = [];
+    if (fs.existsSync(key)) {
+      try { arr = JSON.parse(fs.readFileSync(key, 'utf8')).history || []; }
+      catch (_) { arr = []; }
+    }
+    _histCache.set(name, arr);
+    return arr;
+  }
+
+  function _histSave(name, arr) {
+    _histCache.set(name, arr);
+    try { fs.writeFileSync(_histKey(name), JSON.stringify({ history: arr })); }
+    catch (_) { /* best-effort */ }
+  }
+
+  function _histPush(name, line) {
+    if (!line || !line.trim()) return;
+    const arr = _histLoad(name);
+    // Deduplicate: remove previous identical entry, push to end
+    const idx = arr.lastIndexOf(line);
+    if (idx !== -1) arr.splice(idx, 1);
+    arr.push(line);
+    // Cap at 500 entries
+    if (arr.length > 500) arr.splice(0, arr.length - 500);
+    _histSave(name, arr);
+  }
+
+  // ── password hashing ────────────────────────────────────────────────────
+  //
+  // Returns: { raw, hash, algo, verify(input) }
+  //
+  function _hashPassword(raw, algo = 'sha256') {
+    const hashed = crypto.createHash(algo).update(raw).digest('hex');
+    return {
+      raw,
+      hash: hashed,
+      algo,
+      verify: (input) => crypto.createHash(algo).update(input).digest('hex') === hashed,
+    };
+  }
+
+  // ── core prompt (sync) ──────────────────────────────────────────────────
+  //
+  // opts:
+  //   password   {boolean}         — mask input with '•'
+  //   mask       {string}          — custom mask char (default '•')
+  //   historyKey {string|false}    — key for history persistence (default 'default')
+  //   highlight  {string|fn|false} — theme name or custom fn
+  //   placeholder{string}          — grey hint when empty
+  //   hash       {string|false}    — hash algorithm for password result (sha256)
+  //
+  function prompt(message = '> ', opts = {}) {
+    const {
+      password = false,
+      mask = '•',
+      historyKey = 'default',
+      highlight = false,
+      placeholder = '',
+      hash = false,
+    } = opts;
+
+    const hist = historyKey !== false ? _histLoad(String(historyKey)) : [];
+    const hlFn = highlight === false ? null
+      : typeof highlight === 'function' ? highlight
+        : SyntaxHighlight.get(String(highlight));
+
+    const maskChar = password ? String(mask) : null;
+    const result = _syncReadLine(message, { mask: maskChar, history: hist, highlight: hlFn, placeholder });
+
+    if (historyKey !== false && !password) _histPush(String(historyKey), result);
+
+    if (password && hash) return _hashPassword(result, typeof hash === 'string' ? hash : 'sha256');
+    return result;
+  }
+
+  // ── promptAsync (async version of prompt) ──────────────────────────────
+  async function promptAsync(message = '> ', opts = {}) {
+    // Runs prompt in a microtask so it doesn't block the event-loop scheduler
+    // (on Node the synchronous stdin.read inside _syncReadLine is still
+    // blocking, but wrapping in a Promise lets callers await it naturally)
+    return new Promise((resolve) => {
+      setImmediate(() => resolve(prompt(message, opts)));
+    });
+  }
+
+  // ── promptPassword (sync convenience) ──────────────────────────────────
+  function promptPassword(message = 'Password: ', algo = 'sha256') {
+    return prompt(message, { password: true, hash: algo });
+  }
+
+  // ── promptPasswordAsync ─────────────────────────────────────────────────
+  async function promptPasswordAsync(message = 'Password: ', algo = 'sha256') {
+    return promptAsync(message, { password: true, hash: algo });
+  }
+
+  // ── repl (sync) ─────────────────────────────────────────────────────────
+  //
+  // opts:
+  //   prompt     {string}          — prompt string (default '> ')
+  //   banner     {string}          — printed before loop starts
+  //   historyKey {string}          — history key (default 'repl')
+  //   highlight  {string|fn|false}
+  //   eval       {fn}              — handler(line, ctx) → string|undefined
+  //                                  return '__exit__' to quit
+  //   exit       {string[]}        — words that quit the repl (default ['exit','quit','.q'])
+  //   context    {object}          — arbitrary context passed to eval
+  //   maxHistory {number}          — max history size (default 500)
+  //
+  function repl(opts = {}) {
+    const {
+      prompt: promptStr = '> ',
+      banner: bannerStr = '',
+      historyKey: hk = 'repl',
+      highlight: hl = false,
+      eval: evalFn = null,
+      exit: exitWords = ['exit', 'quit', '.q'],
+      context: ctx = {},
+      maxHistory: _maxHist = 500,
+    } = opts;
+
+    if (bannerStr) process.stdout.write(bannerStr + '\n');
+
+    const hlFn = hl === false ? null
+      : typeof hl === 'function' ? hl
+        : SyntaxHighlight.get(String(hl));
+
+    while (true) {
+      const line = prompt(promptStr, { historyKey: hk, highlight: hlFn });
+
+      if (line === null) break;                              // EOF / Ctrl-D
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      if (exitWords.includes(trimmed.toLowerCase())) break;
+
+      let out;
+      if (evalFn) {
+        try { out = evalFn(trimmed, ctx); }
+        catch (e) { out = `\x1b[31mError: ${e && e.message ? e.message : e}\x1b[0m`; }
+      }
+      if (out === '__exit__') break;
+      if (out !== undefined && out !== null) process.stdout.write(String(out) + '\n');
+    }
+  }
+
+  // ── replAsync ───────────────────────────────────────────────────────────
+  async function replAsync(opts = {}) {
+    const {
+      prompt: promptStr = '> ',
+      banner: bannerStr = '',
+      historyKey: hk = 'repl',
+      highlight: hl = false,
+      eval: evalFn = null,
+      exit: exitWords = ['exit', 'quit', '.q'],
+      context: ctx = {},
+    } = opts;
+
+    if (bannerStr) process.stdout.write(bannerStr + '\n');
+
+    const hlFn = hl === false ? null
+      : typeof hl === 'function' ? hl
+        : SyntaxHighlight.get(String(hl));
+
+    while (true) {
+      const line = await promptAsync(promptStr, { historyKey: hk, highlight: hlFn });
+
+      if (line === null) break;
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      if (exitWords.includes(trimmed.toLowerCase())) break;
+
+      let out;
+      if (evalFn) {
+        try {
+          const raw = evalFn(trimmed, ctx);
+          out = raw instanceof Promise ? await raw : raw;
+        } catch (e) {
+          out = `\x1b[31mError: ${e && e.message ? e.message : e}\x1b[0m`;
+        }
+      }
+      if (out === '__exit__') break;
+      if (out !== undefined && out !== null) process.stdout.write(String(out) + '\n');
+    }
+  }
+
+  // ── mouse — terminal mouse / click events ───────────────────────────────
+  //
+  // Enables SGR mouse reporting and calls cb({ type, button, x, y, ... })
+  // for every mouse event.  Returns a stop() function.
+  //
+  // opts:
+  //   buttons  {boolean}  — report button press/release (default true)
+  //   motion   {boolean}  — report mouse motion (default false)
+  //   scroll   {boolean}  — report scroll events (default true)
+  //
+  function mouse(cb, opts = {}) {
+    const { buttons = true, motion = false, scroll = true } = opts;
+
+    const stdin = process.stdin;
+    const stdout = process.stdout;
+
+    // Enable mouse
+    stdout.write(_ansi.mouseOn);
+    if (stdin.isTTY) stdin.setRawMode(true);
+    stdin.resume();
+
+    function onData(raw) {
+      // SGR mouse: ESC [ < Pb ; Px ; Py M/m
+      const sgr = raw.toString().match(/\x1b\[<(\d+);(\d+);(\d+)([Mm])/);
+      if (sgr) {
+        const btn = parseInt(sgr[1], 10);
+        const x = parseInt(sgr[2], 10) - 1;
+        const y = parseInt(sgr[3], 10) - 1;
+        const release = sgr[4] === 'm';
+        const button = btn & 3;
+        const isScroll = btn >= 64;
+        const isMotion = !!(btn & 32);
+
+        if (!scroll && isScroll) return;
+        if (!motion && isMotion && !release) return;
+        if (!buttons && !isScroll && !isMotion) return;
+
+        cb({
+          type: release ? 'mouseup' : (isScroll ? 'scroll' : (isMotion ? 'mousemove' : 'mousedown')),
+          button,
+          x, y,
+          shift: !!(btn & 4),
+          alt: !!(btn & 8),
+          ctrl: !!(btn & 16),
+          direction: isScroll ? ((btn & 1) ? 'down' : 'up') : null,
+          raw: { btn, x, y, release },
+        });
+        return;
+      }
+
+      // Ctrl-C passthrough so user can still quit
+      if (raw.includes('\x03')) {
+        stop();
+        stdout.write('\n');
+        process.exit(130);
+      }
+    }
+
+    stdin.on('data', onData);
+
+    function stop() {
+      stdout.write(_ansi.mouseOff);
+      stdin.removeListener('data', onData);
+      if (stdin.isTTY) stdin.setRawMode(false);
+      stdin.pause();
+    }
+
+    return stop;
+  }
+
+  // ── history helpers exposed to Nova scripts ─────────────────────────────
+  const historyAPI = {
+    /** Load history array for a given key */
+    load: (name) => _histLoad(String(name)),
+    /** Save a history array for a given key */
+    save: (name, arr) => _histSave(String(name), arr),
+    /** Push a single entry to a history key */
+    push: (name, entry) => _histPush(String(name), String(entry)),
+    /** Clear history for a key */
+    clear: (name) => _histSave(String(name), []),
+    /** List all history keys managed by InputMgr */
+    keys: () => {
+      try {
+        return fs.readdirSync('.').filter(f => f.startsWith('.184.inputmgr.'))
+          .map(f => f.slice('.184.inputmgr.'.length));
+      } catch (_) { return []; }
+    },
+  };
+
+  return {
+    // ── Sync API (primary) ────────────────────────────────────────────────
+    prompt,
+    promptPassword,
+    repl,
+
+    // ── Async API ─────────────────────────────────────────────────────────
+    promptAsync,
+    promptPasswordAsync,
+    replAsync,
+
+    // ── Mouse / terminal events ────────────────────────────────────────────
+    mouse,
+
+    // ── Syntax highlighting ────────────────────────────────────────────────
+    SyntaxHighlight,
+    highlight: SyntaxHighlight.highlight.bind(SyntaxHighlight),
+
+    // ── Password hashing utility (standalone) ─────────────────────────────
+    hashPassword: _hashPassword,
+
+    // ── History management ────────────────────────────────────────────────
+    history: historyAPI,
+  };
+})();
+
+// ═════════════════════════════════════════════════════════════════════════════
+//  Module exports
+// ═════════════════════════════════════════════════════════════════════════════
+module.exports = {
+  // ── Original exports (all preserved) ──────────────────────────────────
+  Air, Chalk, History,
+  Shema, ShemaType,
+  CustomError, formatError, NovaException,
+  ConfigFile,
+  JsDB, Storage, Zip, Crypto,
+  PathUtils, Base64,
+  MED: MathExprDebugger,
+
+  // ── New: InputMgr + SyntaxHighlight ───────────────────────────────────
+  InputMgr,
+  SyntaxHighlight,
+};