fenrir-runtime 0.0.1 → 0.3.0

package/src/runtime/runner.js

@@ -0,0 +1,383 @@
+import { spawn } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import crypto from 'crypto';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const transformCache = new Map();
+
+function getCacheKey(source) {
+  return crypto.createHash('md5').update(source).digest('hex');
+}
+
+function transformFString(line) {
+  return line.replace(/f"((?:[^"\\]|\\.)*)"/g, (_, content) => {
+    const converted = content.replace(/\{([^}]+)\}/g, '${$1}');
+    return '`' + converted + '`';
+  }).replace(/f'((?:[^'\\]|\\.)*)'/g, (_, content) => {
+    const converted = content.replace(/\{([^}]+)\}/g, '${$1}');
+    return '`' + converted + '`';
+  });
+}
+
+function transformPipe(line) {
+  if (!line.includes('|>')) return line;
+
+  // Handle assignment: "const x = a |> b |> c"
+  const assignMatch = line.match(/^((?:const|let|var)\s+\w+\s*=\s*)(.+)$/);
+  const prefix = assignMatch ? assignMatch[1] : '';
+  const expr   = assignMatch ? assignMatch[2] : line;
+
+  if (!expr.includes('|>')) return line;
+
+  const parts = expr.split('|>').map(s => s.trim());
+  let result = parts[0];
+  for (let i = 1; i < parts.length; i++) {
+    const fn = parts[i];
+    if (fn.includes('(')) {
+      result = fn.replace(/\(/, `(${result}, `);
+    } else {
+      result = `${fn}(${result})`;
+    }
+  }
+  return prefix + result;
+}
+
+function transformMatch(lines, startIdx) {
+  const matchLine = lines[startIdx].trim();
+  const m = matchLine.match(/^match\s+(.+?)\s*\{?\s*$/);
+  if (!m) return null;
+  const subject = m[1];
+  const arms = [];
+  let i = startIdx + 1;
+  let braceDepth = matchLine.endsWith('{') ? 1 : 0;
+  if (!matchLine.endsWith('{') && i < lines.length && lines[i].trim() === '{') {
+    i++;
+    braceDepth = 1;
+  }
+  while (i < lines.length && braceDepth > 0) {
+    const l = lines[i].trim();
+    if (l === '}') { braceDepth--; i++; continue; }
+    const arm = l.match(/^(.+?)\s*=>\s*(.+)$/);
+    if (arm) {
+      arms.push({ pattern: arm[1].trim(), body: arm[2].trim() });
+    }
+    i++;
+  }
+  const cases = arms.map(({ pattern, body }) => {
+    if (pattern === '_') return `  default: { ${body}; break; }`;
+    if (/^-?\d+$/.test(pattern) || pattern.startsWith('"') || pattern.startsWith("'")) {
+      return `  case ${pattern}: { ${body}; break; }`;
+    }
+    return `  case ${pattern}: { ${body}; break; }`;
+  });
+  const switchCode = `switch (${subject}) {\n${cases.join('\n')}\n}`;
+  return { code: switchCode, nextIdx: i };
+}
+
+function precompileLocal(fnrPath, dir) {
+  const hash = crypto.createHash('md5').update(fnrPath).digest('hex').slice(0, 8);
+  const outFile = path.join(dir, `dep_${hash}.mjs`);
+  if (fs.existsSync(outFile)) return outFile;
+  const src = fs.readFileSync(fnrPath, 'utf8');
+  const compiled = transform(src, fnrPath, dir);
+  const stdlibPath = path.join(__dirname, '..', 'stdlib', 'index.js');
+  const inject = fs.existsSync(stdlibPath)
+    ? `import { injectGlobals } from "file://${stdlibPath}";\ninjectGlobals();\n`
+    : '';
+  fs.writeFileSync(outFile, inject + '\n' + compiled, 'utf8');
+  return outFile;
+}
+
+function transform(source, filePath, precompileDir = null) {
+  const cacheKey = getCacheKey(source) + (precompileDir || '');
+  if (transformCache.has(cacheKey)) return transformCache.get(cacheKey);
+
+  const lines = source.split('\n');
+  const out = [];
+  let i = 0;
+
+  while (i < lines.length) {
+    let raw = lines[i];
+    const line = raw.trim();
+    i++;
+
+    if (!line) { out.push(''); continue; }
+    if (line.startsWith('//') || line.startsWith('/*') || line.startsWith('*')) { out.push(raw); continue; }
+
+    if (line.startsWith('use ') && line.includes(' from ')) {
+      const m = line.match(/^use\s+(.*?)\s+from\s+(['"])(.*?)\2\s*;?$/);
+      if (m) {
+        const [, spec,, mod] = m;
+        const isLocal = /^\.\.\//.test(mod) || /^\.\//.test(mod) || mod.startsWith('/');
+        if (isLocal) {
+          const absPath = path.resolve(path.dirname(filePath), mod);
+          if (absPath.endsWith('.fnr') && precompileDir) {
+            const compiled = precompileLocal(absPath, precompileDir);
+            out.push(`import ${spec} from "file://${compiled}";`);
+          } else {
+            out.push(`import ${spec} from "file://${absPath}";`);
+          }
+        } else {
+          out.push(`import ${spec} from "${mod}";`);
+        }
+      } else { out.push(raw); }
+      continue;
+    }
+
+    if (line.startsWith('match ')) {
+      const result = transformMatch(lines, i - 1);
+      if (result) {
+        out.push(result.code);
+        i = result.nextIdx;
+        continue;
+      }
+    }
+
+    if (line.startsWith('async fn ') || line.startsWith('fn ')) {
+      out.push(sh(raw).replace(/\basync fn\s+/, 'async function ').replace(/\bfn\s+/, 'function '));
+      continue;
+    }
+
+    if (line.startsWith('type ') && line.includes('=')) continue;
+    if (isJs(line)) { out.push(sh(transformFString(transformPipe(raw)))); continue; }
+
+    if (!bal(line)) {
+      let full = raw;
+      while (i < lines.length && !bal(full)) { full += '\n' + lines[i]; i++; }
+      const s = sh(transformFString(transformPipe(full)));
+      out.push(s + (semi(s.trim()) ? ';' : ''));
+      continue;
+    }
+
+    const s = sh(transformFString(transformPipe(raw)));
+    out.push(s.trim() + (semi(s.trim()) ? ';' : ''));
+  }
+
+  const result = out.join('\n');
+  transformCache.set(cacheKey, result);
+  return result;
+}
+
+const sh = c => c
+  .replace(/\blog\(/g, 'console.log(')
+  .replace(/\berr\(/g, 'console.error(')
+  .replace(/\bwarn\(/g, 'console.warn(')
+  .replace(/\binfo\(/g, 'console.info(')
+  .replace(/\basync fn\b/g, 'async function')
+  .replace(/\bfn\b/g, 'function');
+
+function ch(s, c) { let n=0,inS=false,sC=''; for(let j=0;j<s.length;j++){const x=s[j];if(inS){if(x==='\\'){j++;continue}if(x===sC)inS=false;continue}if(x==='"'||x==="'"){inS=true;sC=x;continue}if(x===c)n++}return n; }
+const bal = s => ch(s,'(')=== ch(s,')')&& ch(s,'[')=== ch(s,']')&& ch(s,'{')=== ch(s,'}');
+
+function isJs(l) {
+  return l.startsWith('import ')||l.startsWith('export ')||l.startsWith('class ')||
+    l.startsWith('function ')||l.startsWith('async function ')||
+    l.startsWith('if ')||l.startsWith('if(')||l.startsWith('else')||l.startsWith('} else')||
+    l.startsWith('for ')||l.startsWith('for(')||l.startsWith('while ')||l.startsWith('while(')||
+    l.startsWith('switch ')||l.startsWith('switch(')||l.startsWith('try')||
+    l.startsWith('catch')||l.startsWith('finally')||l.startsWith('return')||
+    l.startsWith('throw ')||l.startsWith('case ')||l.startsWith('default:')||
+    /^}\s*(else|catch|finally)/.test(l)||l==='break'||l==='continue';
+}
+
+function semi(l) {
+  if(!l) return false;
+  if(l.endsWith(';')||l.endsWith('{')||l.endsWith('}')||l.endsWith(',')||l.endsWith('[')||l.endsWith('(')) return false;
+  if(isJs(l)) return false;
+  if(l.endsWith(')')&&!(l.includes('=')||l.includes('console.')||/^[a-zA-Z_$][\w$.]*\s*\(/.test(l)||/^(await|return)\s/.test(l))) return false;
+  return l.includes('=')||l.includes('console.')||
+    l.startsWith('const ')||l.startsWith('let ')||l.startsWith('var ')||
+    l.startsWith('throw ')||l.startsWith('return')||l.startsWith('import ')||
+    /^[a-zA-Z_$][\w$.]*\s*[\(`[]/.test(l)||/^(await|yield)\s/.test(l)||
+    /^\w+\s*(\+\+|--)/.test(l)||/^\w+\s*[+\-*/&|^]=/.test(l);
+}
+
+export async function runFile(filePath, debug=false, sandbox=false) {
+  if (!fs.existsSync(filePath)) { console.error(`\x1b[31m✘ File not found: ${filePath}\x1b[0m`); process.exit(1); }
+
+  const source = fs.readFileSync(filePath, 'utf8');
+  if (!source.trim()) { console.error('\x1b[31m✘ File is empty.\x1b[0m'); process.exit(1); }
+
+  const tempDir = path.join(os.tmpdir(), `fenrir_${Date.now()}`);
+  fs.mkdirSync(tempDir, { recursive: true });
+
+  const userCode = transform(source, filePath, tempDir);
+  const stdlibPath = path.join(__dirname, '..', 'stdlib', 'index.js');
+  const sandboxPath = path.join(__dirname, '..', 'stdlib', 'sandbox.js');
+
+  let inject = '';
+  if (sandbox && fs.existsSync(sandboxPath)) {
+    inject = `import { injectGlobals } from "file://${sandboxPath}";\ninjectGlobals();\n`;
+  } else if (fs.existsSync(stdlibPath)) {
+    inject = `import { injectGlobals } from "file://${stdlibPath}";\ninjectGlobals();\n`;
+  }
+
+  const final = `${inject}\n${userCode}`;
+  if (debug) console.log('\x1b[90m[debug]\x1b[0m\n' + final);
+
+  const tempFile = path.join(tempDir, 'run.mjs');
+  fs.writeFileSync(tempFile, final);
+
+  const root = process.cwd();
+  const cwdMods = path.join(root, 'node_modules');
+  const tempMods = path.join(tempDir, 'node_modules');
+  if (fs.existsSync(cwdMods)) try { cpDir(cwdMods, tempMods); } catch {}
+  const pkg = path.join(root, 'package.json');
+  if (fs.existsSync(pkg)) try { fs.copyFileSync(pkg, path.join(tempDir,'package.json')); } catch {}
+
+  const env = { ...process.env,
+    NODE_PATH: [tempMods, cwdMods, process.env.NODE_PATH].filter(Boolean).join(path.delimiter),
+    ...(sandbox ? { FENRIR_SANDBOX: '1' } : {})
+  };
+
+  const child = spawn('node', [tempFile], { stdio:'inherit', env, cwd:root });
+  child.on('close', code => { del(tempDir); process.exit(code??0); });
+  child.on('error', e => { console.error(`\x1b[31m✘ ${e.message}\x1b[0m`); del(tempDir); process.exit(1); });
+  process.on('SIGINT', () => { del(tempDir); process.exit(130); });
+}
+
+export async function watchFile(filePath, debug=false) {
+  const { default: chokidar } = await import('chokidar');
+  console.log(`\x1b[36m👁  Watching: ${filePath}\x1b[0m`);
+  let child = null;
+
+  const run = () => {
+    if (child) { try { child.kill(); } catch {} }
+    console.log('\x1b[90m─────────────────────────────\x1b[0m');
+    console.log(`\x1b[36m▶  Running ${path.basename(filePath)}\x1b[0m`);
+    const source = fs.readFileSync(filePath, 'utf8');
+    const tempDir = path.join(os.tmpdir(), `fenrir_watch_${Date.now()}`);
+    fs.mkdirSync(tempDir, { recursive: true });
+    const userCode = transform(source, filePath, tempDir);
+    const stdlibPath = path.join(__dirname, '..', 'stdlib', 'index.js');
+    const inject = fs.existsSync(stdlibPath)
+      ? `import { injectGlobals } from "file://${stdlibPath}";\ninjectGlobals();\n`
+      : '';
+    const final = `${inject}\n${userCode}`;
+    const tempFile = path.join(tempDir, 'run.mjs');
+    fs.writeFileSync(tempFile, final);
+    const root = process.cwd();
+    const cwdMods = path.join(root, 'node_modules');
+    const tempMods = path.join(tempDir, 'node_modules');
+    if (fs.existsSync(cwdMods)) try { cpDir(cwdMods, tempMods); } catch {}
+    const pkg = path.join(root, 'package.json');
+    if (fs.existsSync(pkg)) try { fs.copyFileSync(pkg, path.join(tempDir, 'package.json')); } catch {}
+    const env = { ...process.env, NODE_PATH: [tempMods, cwdMods, process.env.NODE_PATH].filter(Boolean).join(path.delimiter) };
+    child = spawn('node', [tempFile], { stdio: 'inherit', env, cwd: root });
+    child.on('close', code => {
+      del(tempDir);
+      console.log(`\x1b[90m[exited: ${code}]\x1b[0m`);
+    });
+  };
+
+  run();
+  chokidar.watch(filePath, { ignoreInitial: true }).on('change', () => {
+    console.log(`\x1b[33m⟳  Changed, restarting...\x1b[0m`);
+    run();
+  });
+}
+
+export function formatFile(filePath) {
+  const source = fs.readFileSync(filePath, 'utf8');
+  const lines = source.split('\n');
+  const out = [];
+  let indent = 0;
+  const TAB = '  ';
+
+  for (const raw of lines) {
+    const line = raw.trim();
+    if (!line) { out.push(''); continue; }
+
+    const closes = (line.match(/^[}\])]/) || []).length;
+    if (closes) indent = Math.max(0, indent - closes);
+
+    out.push(TAB.repeat(indent) + line);
+
+    const opens = (line.match(/[{[(]$/) || []).length;
+    const closeInline = (line.match(/[}\])]$/) && !line.match(/^[}\]]/) || []).length;
+    if (opens && !closeInline) indent++;
+  }
+
+  const formatted = out.join('\n');
+  fs.writeFileSync(filePath, formatted, 'utf8');
+  console.log(`\x1b[32m✓  Formatted: ${filePath}\x1b[0m`);
+}
+
+export function lintFile(filePath) {
+  const source = fs.readFileSync(filePath, 'utf8');
+  const lines = source.split('\n');
+  const issues = [];
+
+  lines.forEach((raw, idx) => {
+    const line = raw.trim();
+    const ln = idx + 1;
+    if (line.length > 120) issues.push({ ln, msg: `Line too long (${line.length} chars)` });
+    if (/\bconsole\.log\b/.test(line)) issues.push({ ln, msg: 'Use print() instead of console.log()' });
+    if (/var\s+/.test(line) && !line.startsWith('//')) issues.push({ ln, msg: 'Prefer const/let over var' });
+    if (/==(?!=)/.test(line) && !line.startsWith('//')) issues.push({ ln, msg: 'Use === instead of ==' });
+    if (/!=(?!=)/.test(line) && !line.startsWith('//')) issues.push({ ln, msg: 'Use !== instead of !=' });
+  });
+
+  if (!issues.length) {
+    console.log(`\x1b[32m✓  No issues found in ${filePath}\x1b[0m`);
+    return;
+  }
+  console.log(`\x1b[33m⚠  ${issues.length} issue(s) in ${filePath}:\x1b[0m`);
+  for (const { ln, msg } of issues) {
+    console.log(`  \x1b[90mline ${ln}:\x1b[0m ${msg}`);
+  }
+}
+
+export function bundleFile(entryPath, outPath) {
+  const visited = new Set();
+  const chunks = [];
+
+  function collect(fp) {
+    const abs = path.resolve(fp);
+    if (visited.has(abs)) return;
+    visited.add(abs);
+    const src = fs.readFileSync(abs, 'utf8');
+    const lines = src.split('\n');
+    const out = [];
+    for (const line of lines) {
+      const m = line.trim().match(/^(?:use|import)\s+.*?\s+from\s+['"](\..+?)['"]/);
+      if (m) {
+        const dep = path.resolve(path.dirname(abs), m[1]);
+        const candidates = [dep, dep + '.js', dep + '.fnr', dep + '/index.js'];
+        for (const c of candidates) {
+          if (fs.existsSync(c)) { collect(c); break; }
+        }
+        continue;
+      }
+      out.push(line);
+    }
+    chunks.push(`\n// === ${path.relative(process.cwd(), abs)} ===\n` + out.join('\n'));
+  }
+
+  collect(entryPath);
+  const stdlibPath = path.join(__dirname, '..', 'stdlib', 'index.js');
+  const inject = fs.existsSync(stdlibPath)
+    ? `import { injectGlobals } from "file://${stdlibPath}";\ninjectGlobals();\n`
+    : '';
+  const bundle = inject + chunks.join('\n');
+  const dest = outPath || entryPath.replace(/\.(fnr|js)$/, '.bundle.mjs');
+  fs.writeFileSync(dest, bundle, 'utf8');
+  console.log(`\x1b[32m✓  Bundled → ${dest}\x1b[0m`);
+}
+
+const del = dir => { try { fs.rmSync(dir,{recursive:true,force:true}); } catch {} };
+
+function cpDir(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  for (const e of fs.readdirSync(src, { withFileTypes: true })) {
+    const s = path.join(src, e.name), d = path.join(dest, e.name);
+    if (e.isSymbolicLink()) try { cpDir(fs.realpathSync(s),d); } catch {}
+    else if (e.isDirectory()) cpDir(s,d);
+    else try { fs.copyFileSync(s,d); } catch {}
+  }
+}

package/src/stdlib/index.js

@@ -0,0 +1,297 @@
+import fs from 'fs';
+import path from 'path';
+import http from 'http';
+import { execSync, spawn as nodeSpawn } from 'child_process';
+import { createInterface } from 'readline';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const fmt = v => v===null?'null':v===undefined?'undefined':typeof v==='object'?JSON.stringify(v,null,2):String(v);
+
+export const print = (...a) => { process.stdout.write(a.map(fmt).join(' ')+'\n'); };
+export const log   = print;
+export const err   = (...a) => { process.stderr.write(a.map(fmt).join(' ')+'\n'); };
+export const warn  = (...a) => { process.stderr.write('\x1b[33m'+a.map(fmt).join(' ')+'\x1b[0m\n'); };
+export const info  = (...a) => { process.stdout.write('\x1b[36m'+a.map(fmt).join(' ')+'\x1b[0m\n'); };
+
+export const prompt = q => new Promise(r => {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  rl.question(q, a => { rl.close(); r(a); });
+});
+
+export const readFile   = p => fs.readFileSync(path.resolve(p), 'utf8');
+export const writeFile  = (p,c) => { fs.writeFileSync(path.resolve(p), c, 'utf8'); };
+export const appendFile = (p,c) => { fs.appendFileSync(path.resolve(p), c, 'utf8'); };
+export const fileExists = p => fs.existsSync(path.resolve(p));
+export const readDir    = p => fs.readdirSync(path.resolve(p));
+export const readJSON   = p => JSON.parse(readFile(p));
+export const writeJSON  = (p,d) => writeFile(p, JSON.stringify(d,null,2));
+export const mkdir      = p => { fs.mkdirSync(path.resolve(p), { recursive: true }); };
+export const rm         = p => { fs.rmSync(path.resolve(p), { recursive: true, force: true }); };
+
+export const get  = async (url, headers) => { const r=await fetch(url,{headers}); const t=await r.text(); try{return JSON.parse(t)}catch{return t}};
+export const post = async (url, body, headers) => { const r=await fetch(url,{method:'POST',headers:{'Content-Type':'application/json',...headers},body:JSON.stringify(body)}); const t=await r.text(); try{return JSON.parse(t)}catch{return t}};
+
+export const exec  = cmd => execSync(cmd, { encoding:'utf8', stdio:['pipe','pipe','pipe'] }).trim();
+export const run   = cmd => { execSync(cmd, { stdio:'inherit' }); };
+export const spawn = (cmd, args=[]) => new Promise((res,rej) => {
+  const c = nodeSpawn(cmd, args, { stdio:'inherit' });
+  c.on('close', res); c.on('error', rej);
+});
+
+export const env   = (k, fb='') => process.env[k] ?? fb;
+export const args  = () => process.argv.slice(2);
+export const exit  = (c=0) => process.exit(c);
+export const cwd   = () => process.cwd();
+
+export const now  = () => Date.now();
+export const time = () => new Date().toISOString();
+export const sleep = ms => new Promise(r => setTimeout(r, ms));
+export const bench = async (label, fn) => { const s=performance.now(); await fn(); info(`[bench] ${label}: ${(performance.now()-s).toFixed(2)}ms`); };
+
+export const range = (start, end, step=1) => { if(end===undefined){end=start;start=0;} const r=[];for(let i=start;i<end;i+=step)r.push(i);return r; };
+export const rand    = (min=0,max=1) => Math.random()*(max-min)+min;
+export const randInt = (min,max) => Math.floor(rand(min,max+1));
+export const pick    = arr => arr[randInt(0,arr.length-1)];
+export const shuffle = arr => { const a=[...arr]; for(let i=a.length-1;i>0;i--){const j=randInt(0,i);[a[i],a[j]]=[a[j],a[i]];} return a; };
+export const chunk   = (arr,n) => { const r=[];for(let i=0;i<arr.length;i+=n)r.push(arr.slice(i,i+n));return r; };
+export const unique  = arr => [...new Set(arr)];
+export const flatten = arr => arr.flat(Infinity);
+export const sum     = arr => arr.reduce((a,b)=>a+b,0);
+export const avg     = arr => sum(arr)/arr.length;
+export const min     = (...a) => Math.min(...(Array.isArray(a[0])?a[0]:a));
+export const max     = (...a) => Math.max(...(Array.isArray(a[0])?a[0]:a));
+export const clamp   = (n,lo,hi) => Math.max(lo,Math.min(hi,n));
+
+export const capitalize = s => s.charAt(0).toUpperCase()+s.slice(1);
+export const truncate   = (s,n,suf='...') => s.length>n?s.slice(0,n)+suf:s;
+export const pad        = (s,n,c=' ') => String(s).padStart(n,c);
+export const repeat     = (s,n) => s.repeat(n);
+
+export const keys    = o => Object.keys(o);
+export const values  = o => Object.values(o);
+export const entries = o => Object.entries(o);
+export const merge   = (...os) => Object.assign({},...os);
+export const clone   = v => JSON.parse(JSON.stringify(v));
+
+export const all   = ps => Promise.all(ps);
+export const race  = ps => Promise.race(ps);
+export const retry = async (fn,times=3,delay=500) => { for(let i=0;i<times;i++){try{return await fn()}catch(e){if(i===times-1)throw e;await sleep(delay);}} };
+
+export const isString = v => typeof v==='string';
+export const isNumber = v => typeof v==='number';
+export const isBool   = v => typeof v==='boolean';
+export const isArray  = v => Array.isArray(v);
+export const isObject = v => v!==null&&typeof v==='object'&&!Array.isArray(v);
+export const isNull   = v => v===null;
+export const isDefined= v => v!==undefined&&v!==null;
+
+export const { abs,ceil,floor,round,sqrt,pow,PI,E,log2,log10,sin,cos,tan } = Math;
+
+export function serve(port, handler) {
+  const server = http.createServer(async (req, res) => {
+    let body = '';
+    req.on('data', d => body += d);
+    req.on('end', async () => {
+      const request = {
+        method: req.method,
+        url: req.url,
+        headers: req.headers,
+        body: body ? ((() => { try { return JSON.parse(body); } catch { return body; } })()) : null,
+        params: Object.fromEntries(new URL(req.url, `http://localhost`).searchParams),
+      };
+      try {
+        const result = await handler(request);
+        if (typeof result === 'string') {
+          res.writeHead(200, { 'Content-Type': 'text/plain' });
+          res.end(result);
+        } else if (result && typeof result === 'object') {
+          if (result.__raw) {
+            res.writeHead(result.status || 200, result.headers || {});
+            res.end(result.body ?? '');
+          } else {
+            res.writeHead(result.status || 200, { 'Content-Type': 'application/json', ...(result.headers||{}) });
+            res.end(JSON.stringify(result.body ?? result));
+          }
+        } else {
+          res.writeHead(200); res.end(String(result ?? ''));
+        }
+      } catch(e) {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: e.message }));
+      }
+    });
+  });
+  server.listen(port, () => info(`[serve] Listening on http://localhost:${port}`));
+  return server;
+}
+
+export function response(body, status=200, headers={}) {
+  return { __raw: true, body: typeof body === 'object' ? JSON.stringify(body) : body, status, headers: { 'Content-Type': typeof body === 'object' ? 'application/json' : 'text/plain', ...headers } };
+}
+
+export async function openDb(dbPath) {
+  let initSqlJs;
+  try {
+    const m = await import('sql.js');
+    initSqlJs = m.default;
+  } catch {
+    throw new Error('sql.js not found. Run: fenrir install sql.js');
+  }
+
+  const SQL = await initSqlJs();
+  const absPath = dbPath && dbPath !== ':memory:' ? path.resolve(dbPath) : null;
+  const db = absPath && fs.existsSync(absPath)
+    ? new SQL.Database(fs.readFileSync(absPath))
+    : new SQL.Database();
+
+  const save = () => {
+    if (absPath) fs.writeFileSync(absPath, Buffer.from(db.export()));
+  };
+
+  return {
+    query(sql, ...params) {
+      if (/^\s*(select|pragma)/i.test(sql)) {
+        const stmt = db.prepare(sql);
+        stmt.bind(params);
+        const rows = [];
+        while (stmt.step()) rows.push(stmt.getAsObject());
+        stmt.free();
+        return rows;
+      }
+      db.run(sql, params);
+      save();
+      return { changes: db.getRowsModified() };
+    },
+    run(sql, ...params)  { db.run(sql, params); save(); return { changes: db.getRowsModified() }; },
+    get(sql, ...params)  {
+      const stmt = db.prepare(sql);
+      stmt.bind(params);
+      const row = stmt.step() ? stmt.getAsObject() : null;
+      stmt.free();
+      return row;
+    },
+    all(sql, ...params)  {
+      const stmt = db.prepare(sql);
+      stmt.bind(params);
+      const rows = [];
+      while (stmt.step()) rows.push(stmt.getAsObject());
+      stmt.free();
+      return rows;
+    },
+    exec(sql)   { db.run(sql); save(); },
+    close()     { save(); db.close(); },
+    transaction(fn) {
+      db.run('BEGIN');
+      try { fn(); db.run('COMMIT'); save(); }
+      catch(e) { db.run('ROLLBACK'); throw e; }
+    },
+  };
+}
+
+export async function parse(input, typeHint) {
+  const str = typeof input === 'string' && fs.existsSync(input)
+    ? fs.readFileSync(input, 'utf8')
+    : String(input);
+
+  const ext = typeof input === 'string' ? path.extname(input).toLowerCase() : '';
+  const hint = typeHint || ext;
+
+  if (hint === '.csv' || hint === 'csv') return parseCsv(str);
+  if (hint === '.toml' || hint === 'toml') {
+    try { const { default: toml } = await import('toml'); return toml.parse(str); } catch { throw new Error('toml not found. Run: fenrir install toml'); }
+  }
+  if (hint === '.yaml' || hint === '.yml' || hint === 'yaml') {
+    try { const { default: yaml } = await import('js-yaml'); return yaml.load(str); } catch { throw new Error('js-yaml not found. Run: fenrir install js-yaml'); }
+  }
+
+  try { return JSON.parse(str); } catch {}
+  try {
+    const { default: yaml } = await import('js-yaml');
+    return yaml.load(str);
+  } catch {}
+  if (str.includes(',')) return parseCsv(str);
+  return str;
+}
+
+function parseCsv(str) {
+  const lines = str.trim().split('\n');
+  if (!lines.length) return [];
+  const headers = lines[0].split(',').map(h => h.trim().replace(/^"|"$/g, ''));
+  return lines.slice(1).map(line => {
+    const vals = line.split(',').map(v => v.trim().replace(/^"|"$/g, ''));
+    return Object.fromEntries(headers.map((h, i) => [h, vals[i] ?? '']));
+  });
+}
+
+export function cache(ttlMs = 60000) {
+  const store = new Map();
+  return {
+    get: key => {
+      const entry = store.get(key);
+      if (!entry) return undefined;
+      if (Date.now() > entry.expires) { store.delete(key); return undefined; }
+      return entry.value;
+    },
+    set: (key, value, customTtl) => {
+      store.set(key, { value, expires: Date.now() + (customTtl ?? ttlMs) });
+    },
+    has: key => {
+      const entry = store.get(key);
+      if (!entry) return false;
+      if (Date.now() > entry.expires) { store.delete(key); return false; }
+      return true;
+    },
+    del: key => store.delete(key),
+    clear: () => store.clear(),
+    size: () => store.size,
+    wrap: async (key, fn, customTtl) => {
+      const cached = store.get(key);
+      if (cached && Date.now() <= cached.expires) return cached.value;
+      const value = await fn();
+      store.set(key, { value, expires: Date.now() + (customTtl ?? ttlMs) });
+      return value;
+    }
+  };
+}
+
+export function pipe(...fns) {
+  return async (input) => {
+    let result = input;
+    for (const fn of fns) result = await fn(result);
+    return result;
+  };
+}
+
+export function assert(condition, message = 'Assertion failed') {
+  if (!condition) throw new Error(`\x1b[31m✘ Assert: ${message}\x1b[0m`);
+}
+
+export function assertEqual(a, b, message) {
+  const pass = JSON.stringify(a) === JSON.stringify(b);
+  if (!pass) throw new Error(`\x1b[31m✘ Assert equal failed${message ? ': ' + message : ''}\n  expected: ${JSON.stringify(b)}\n  got:      ${JSON.stringify(a)}\x1b[0m`);
+}
+
+export function assertThrows(fn, message) {
+  try { fn(); throw new Error(`\x1b[31m✘ Expected throw${message ? ': ' + message : ''}\x1b[0m`); }
+  catch(e) { if (e.message.startsWith('\x1b[31m✘ Expected')) throw e; }
+}
+
+export function injectGlobals() {
+  Object.assign(globalThis, {
+    print,log,err,warn,info,prompt,
+    readFile,writeFile,appendFile,fileExists,readDir,readJSON,writeJSON,mkdir,rm,
+    get,post,exec,run,spawn,env,args,exit,cwd,
+    now,time,sleep,bench,
+    range,rand,randInt,pick,shuffle,chunk,unique,flatten,sum,avg,min,max,clamp,
+    capitalize,truncate,pad,repeat,
+    keys,values,entries,merge,clone,
+    all,race,retry,
+    isString,isNumber,isBool,isArray,isObject,isNull,isDefined,
+    abs,ceil,floor,round,sqrt,pow,PI,E,log2,log10,sin,cos,tan,
+    serve,response,openDb,parse,cache,pipe,
+    assert,assertEqual,assertThrows,
+  });
+}