thebird 1.2.78 → 1.2.80

package/docs/shell-builtins-extra.js

@@ -0,0 +1,121 @@
+import { resolvePath } from './shell-builtins.js';
+
+const toKey = p => p.replace(/^\//, '');
+const snap = () => window.__debug.idbSnapshot || {};
+
+export function makeExtraBuiltins(ctx, readFile, writeFile) {
+  const w = s => ctx.term.write(s);
+  const wl = s => w(s + '\r\n');
+  return {
+    test: args => { ctx.lastExitCode = evalTest(args) ? 0 : 1; },
+    '[': args => { const inner = args[args.length - 1] === ']' ? args.slice(0, -1) : args; ctx.lastExitCode = evalTest(inner) ? 0 : 1; },
+    tee: (args, _a, stdin) => {
+      const files = args.filter(a => !a.startsWith('-'));
+      const append = args.some(a => a === '-a');
+      const buf = stdin || '';
+      for (const f of files) writeFile(f, append ? (snap()[toKey(resolvePath(ctx.cwd, f))] || '') + buf : buf);
+      w(buf.replace(/\n/g, '\r\n'));
+    },
+    xargs: async (args, _a, stdin, invokeBuiltin) => {
+      const parts = (stdin || '').trim().split(/\s+/).filter(Boolean);
+      if (!args.length || !parts.length) return;
+      await invokeBuiltin(args[0], [...args.slice(1), ...parts], false);
+    },
+    read: (args, _a, stdin) => {
+      const flags = args.filter(a => a.startsWith('-')).join('');
+      const names = args.filter(a => !a.startsWith('-'));
+      if (!names.length) names.push('REPLY');
+      let line = (stdin || '').split('\n')[0];
+      if (!flags.includes('r')) line = line.replace(/\\(.)/g, '$1');
+      line = line.replace(/\r$/, '');
+      const nIdx = flags.indexOf('n');
+      if (nIdx >= 0) { const n = parseInt(flags.slice(nIdx + 1), 10); if (!isNaN(n)) line = line.slice(0, n); }
+      const parts = line.split(/\s+/);
+      for (let i = 0; i < names.length; i++) ctx.env[names[i]] = i === names.length - 1 ? parts.slice(i).join(' ') : parts[i] || '';
+    },
+    printf: args => {
+      if (!args.length) return;
+      let dest = null;
+      if (args[0] === '-v') { dest = args[1]; args = args.slice(2); }
+      if (!args.length) return;
+      const fmt = args[0].replace(/\\n/g, '\n').replace(/\\t/g, '\t').replace(/\\r/g, '\r');
+      let idx = 1;
+      const out = fmt.replace(/%([sdxof])/g, (_, spec) => {
+        const v = args[idx++] ?? '';
+        if (spec === 'd') return String(parseInt(v, 10) || 0);
+        if (spec === 'x') return (parseInt(v, 10) || 0).toString(16);
+        if (spec === 'o') return (parseInt(v, 10) || 0).toString(8);
+        if (spec === 'f') return String(parseFloat(v) || 0);
+        return String(v);
+      });
+      if (dest) ctx.env[dest] = out; else w(out.replace(/\n/g, '\r\n'));
+    },
+    declare: args => {
+      const assoc = args.includes('-A');
+      const arr = args.includes('-a');
+      const names = args.filter(a => !a.startsWith('-'));
+      for (const n of names) { const eq = n.indexOf('='); const k = eq >= 0 ? n.slice(0, eq) : n; if (assoc) { ctx.arrays = ctx.arrays || {}; ctx.arrays[k] = {}; } else if (arr) { ctx.arrays = ctx.arrays || {}; ctx.arrays[k] = []; } else if (eq >= 0) ctx.env[k] = n.slice(eq + 1); }
+    },
+    shift: args => {
+      const n = parseInt(args[0], 10) || 1;
+      ctx.argv = (ctx.argv || []).slice(n);
+    },
+    local: args => {
+      for (const kv of args) {
+        const eq = kv.indexOf('=');
+        const k = eq >= 0 ? kv.slice(0, eq) : kv;
+        const v = eq >= 0 ? kv.slice(eq + 1) : '';
+        (ctx.localStack && ctx.localStack[ctx.localStack.length - 1] || {})[k] = ctx.env[k];
+        ctx.env[k] = v;
+      }
+    },
+    set: args => {
+      for (const a of args) {
+        if (a === '-e') ctx.opts = { ...ctx.opts, errexit: true };
+        else if (a === '+e') ctx.opts = { ...ctx.opts, errexit: false };
+        else if (a === '-x') ctx.opts = { ...ctx.opts, xtrace: true };
+        else if (a === '+x') ctx.opts = { ...ctx.opts, xtrace: false };
+        else if (a === '-u') ctx.opts = { ...ctx.opts, nounset: true };
+      }
+    },
+    break: args => { ctx.loopFlag = 'break'; ctx.loopDepth = parseInt(args[0], 10) || 1; },
+    continue: args => { ctx.loopFlag = 'continue'; ctx.loopDepth = parseInt(args[0], 10) || 1; },
+    source: async (args, _a, _s, invokeBuiltin, runLine) => {
+      if (!args[0]) throw new Error('source: missing file');
+      const content = snap()[toKey(resolvePath(ctx.cwd, args[0]))];
+      if (content == null) throw new Error('source: ' + args[0] + ': No such file');
+      const savedArgv = ctx.argv;
+      ctx.argv = [args[0], ...args.slice(1)];
+      try { if (ctx.runScript) await ctx.runScript(content); else for (const ln of content.split('\n')) if (ln.trim()) await runLine(ln); }
+      finally { ctx.argv = savedArgv; }
+    },
+    '.': async (args, actor, stdin, invokeBuiltin, runLine) => {
+      const src = (ctx.builtinsRef || {}).source;
+      if (src) await src(args, actor, stdin, invokeBuiltin, runLine);
+    },
+  };
+}
+
+function evalTest(args) {
+  if (args.length === 1) return !!args[0];
+  if (args.length === 2) {
+    const [flag, val] = args;
+    const s = () => window.__debug.idbSnapshot || {};
+    const OPS = {
+      '-z': v => v === '', '-n': v => v !== '',
+      '-f': v => v in s(),
+      '-d': v => Object.keys(s()).some(k => k.startsWith(v + '/')),
+      '-e': v => v in s() || Object.keys(s()).some(k => k.startsWith(v + '/')),
+      '!': v => !v,
+    };
+    return OPS[flag]?.(val) ?? false;
+  }
+  if (args.length === 3) {
+    const [a, op, b] = args;
+    const CMP = { '=':(x,y)=>x===y,'==':(x,y)=>x===y,'!=':(x,y)=>x!==y,
+      '-eq':(x,y)=>+x===+y,'-ne':(x,y)=>+x!==+y,
+      '-lt':(x,y)=>+x<+y,'-gt':(x,y)=>+x>+y,'-le':(x,y)=>+x<=+y,'-ge':(x,y)=>+x>=+y };
+    return CMP[op]?.(a, b) ?? false;
+  }
+  return false;
+}

package/docs/shell-builtins-text.js

@@ -0,0 +1,109 @@
+import { resolvePath } from './shell-builtins.js';
+import { runSed } from './shell-sed.js';
+
+const toKey = p => p.replace(/^\//, '');
+const snap = () => window.__debug.idbSnapshot || {};
+const persist = () => window.__debug.idbPersist?.();
+const previewWrite = () => window.__debug.shell?.onPreviewWrite?.();
+
+const readLines = text => text.split('\n').map(l => l.replace(/\r$/, '')).filter((l, i, a) => i < a.length - 1 || l !== '');
+
+function readStdinFirst(positional) {
+  const stdinFirst = positional.length > 0 && positional[0].includes('\n');
+  return { stdin: stdinFirst ? positional[0] : null, rest: stdinFirst ? positional.slice(1) : positional };
+}
+
+export function makeTextBuiltins(ctx, readFile, writeFile) {
+  const w = s => ctx.term.write(s);
+  const wl = s => w(s + '\r\n');
+  return {
+    grep: args => {
+      const flags = args.filter(a => a.startsWith('-')).join('');
+      const positional = args.filter(a => !a.startsWith('-'));
+      const { stdin, rest } = readStdinFirst(positional);
+      const [pat, ...fileArgs] = rest;
+      if (!pat) throw new Error('grep: missing pattern');
+      const re = new RegExp(pat, flags.includes('i') ? 'gi' : 'g');
+      const lineNos = flags.includes('n');
+      const sources = fileArgs.length ? fileArgs.map(f => ({ name: f, text: readFile(f) })) : [{ name: '', text: stdin || '' }];
+      const showFile = sources.length > 1 || flags.includes('H');
+      let matched = 0;
+      for (const { name, text } of sources) {
+        text.split('\n').forEach((l, i) => {
+          re.lastIndex = 0;
+          if (re.test(l)) { wl((showFile && name ? name + ':' : '') + (lineNos ? (i + 1) + ':' : '') + l); matched++; }
+        });
+      }
+      if (!matched) ctx.lastExitCode = 1;
+    },
+    sed: args => {
+      const exprs = [];
+      const files = [];
+      let inplace = false;
+      for (let i = 0; i < args.length; i++) {
+        if (args[i] === '-e') { exprs.push(args[++i]); continue; }
+        if (args[i] === '-i') { inplace = true; continue; }
+        if (args[i].startsWith('-')) continue;
+        if (!exprs.length) exprs.push(args[i]); else files.push(args[i]);
+      }
+      const { stdin, rest } = readStdinFirst(files);
+      const fileArgs = rest;
+      if (!exprs.length) throw new Error('sed: missing expression');
+      const pairs = fileArgs.length ? fileArgs.map(f => [f, readFile(f)]) : [['', stdin || '']];
+      for (const [name, text] of pairs) {
+        const out = runSed(exprs, text);
+        if (name && inplace) writeFile(name, out);
+        else if (name) w(out.replace(/\n/g, '\r\n') + '\r\n');
+        else w(out.replace(/\n/g, '\r\n'));
+      }
+    },
+    sort: args => {
+      const flags = args.filter(a => a.startsWith('-')).join('');
+      const positional = args.filter(a => !a.startsWith('-'));
+      const stdinFirst = positional.length > 0 && positional[0].includes('\n');
+      const stdin = stdinFirst ? positional[0] : null;
+      const fileArgs = stdinFirst ? positional.slice(1) : positional;
+      const targets = fileArgs.length ? fileArgs : [null];
+      for (const f of targets) {
+        let lines = readLines(f ? readFile(f) : stdin || '');
+        if (flags.includes('r')) lines.sort().reverse(); else lines.sort();
+        if (flags.includes('u')) lines = [...new Set(lines)];
+        wl(lines.join('\r\n'));
+      }
+    },
+    uniq: args => {
+      const positional = args.filter(a => !a.startsWith('-'));
+      const stdinFirst = positional.length > 0 && positional[0].includes('\n');
+      const stdin = stdinFirst ? positional[0] : null;
+      const fileArgs = stdinFirst ? positional.slice(1) : positional;
+      const targets = fileArgs.length ? fileArgs : [null];
+      for (const f of targets) {
+        const lines = readLines(f ? readFile(f) : stdin || '');
+        wl(lines.filter((l, i) => i === 0 || l !== lines[i - 1]).join('\r\n'));
+      }
+    },
+    tr: args => {
+      const positional = args.filter(a => !a.startsWith('-'));
+      const stdin = positional.length > 0 ? positional[0] : '';
+      const [from, to] = positional.slice(1);
+      if (!from) throw new Error('tr: missing operand');
+      const mapped = stdin.split('').map(c => {
+        const i = from.indexOf(c);
+        return to == null ? (from.includes(c) ? '' : c) : (i >= 0 ? (to[i] || to[to.length - 1]) : c);
+      }).join('');
+      wl(mapped.replace(/\n/g, '\r\n'));
+    },
+    env: () => wl(Object.entries(ctx.env).map(([k, v]) => k + '=' + v).join('\r\n')),
+    export: args => { for (const kv of args) { const [k, ...v] = kv.split('='); ctx.env[k] = v.join('='); } },
+    clear: () => ctx.term.clear(),
+    history: () => ctx.history.forEach((l, i) => wl(String(i + 1).padStart(5) + '  ' + l)),
+    which: (args, b) => { const cmd = args[0]; if (!cmd) throw new Error('which: missing operand'); if (b[cmd]) wl('(builtin) ' + cmd); else wl(cmd + ' not found'); },
+    exit: (args, actor) => { if (actor.getSnapshot().value === 'node-repl') { actor.send({ type: 'EXIT_REPL' }); wl('[shell]'); } },
+    true: () => {},
+    false: () => { ctx.lastExitCode = 1; },
+    printenv: args => {
+      if (!args.length) wl(Object.entries(ctx.env).map(([k, v]) => k + '=' + v).join('\r\n'));
+      else wl(ctx.env[args[0]] ?? '');
+    },
+  };
+}

package/docs/shell-builtins-util.js

@@ -0,0 +1,112 @@
+import { resolvePath } from './shell-builtins.js';
+import { runAwk } from './shell-awk.js';
+
+const toKey = p => p.replace(/^\//, '');
+const snap = () => window.__debug.idbSnapshot || {};
+
+export function makeUtilBuiltins(ctx, readFile, writeFile) {
+  const w = s => ctx.term.write(s);
+  const wl = s => w(s + '\r\n');
+  return {
+    basename: args => { if (!args[0]) return; const p = args[0].replace(/\/+$/, '').split('/').pop(); wl(args[1] ? p.replace(new RegExp(args[1] + '$'), '') : p); },
+    dirname: args => { if (!args[0]) return; const idx = args[0].replace(/\/+$/, '').lastIndexOf('/'); wl(idx <= 0 ? (idx === 0 ? '/' : '.') : args[0].slice(0, idx)); },
+    realpath: args => { if (!args[0]) return; wl(resolvePath(ctx.cwd, args[0])); },
+    date: args => {
+      const fmt = args.find(a => a.startsWith('+'));
+      const d = new Date();
+      if (!fmt) { wl(d.toUTCString()); return; }
+      const pad = (n, z = 2) => String(n).padStart(z, '0');
+      const MAP = { Y: d.getFullYear(), m: pad(d.getMonth() + 1), d: pad(d.getDate()), H: pad(d.getHours()), M: pad(d.getMinutes()), S: pad(d.getSeconds()), s: Math.floor(d.getTime() / 1000), N: pad(d.getMilliseconds(), 3) + '000000' };
+      wl(fmt.slice(1).replace(/%(.)/g, (_, k) => String(MAP[k] ?? '%' + k)));
+    },
+    find: args => {
+      const start = args.find(a => !a.startsWith('-')) || '.';
+      const nameArg = args[args.indexOf('-name') + 1];
+      const typeArg = args[args.indexOf('-type') + 1];
+      const prefix = toKey(resolvePath(ctx.cwd, start));
+      const keys = Object.keys(snap());
+      const dirs = new Set();
+      for (const k of keys) { const parts = k.split('/'); for (let i = 1; i < parts.length; i++) dirs.add(parts.slice(0, i).join('/')); }
+      const all = [...keys.map(k => ({ path: k, type: 'f' })), ...[...dirs].map(d => ({ path: d, type: 'd' }))];
+      const patToRe = p => new RegExp('^' + p.replace(/[-[\]{}()+.,\\^$|#]/g, c => (c === '*' || c === '?') ? c : '\\' + c).replace(/\*/g, '.*').replace(/\?/g, '.') + '$');
+      const matches = all.filter(e => (!prefix || e.path === prefix || e.path.startsWith(prefix + '/')) && (!nameArg || patToRe(nameArg).test(e.path.split('/').pop())) && (!typeArg || typeArg === e.type));
+      for (const m of matches.sort((a, b) => a.path.localeCompare(b.path))) wl('/' + m.path);
+    },
+    awk: (args, _a, stdin) => {
+      let fs = null;
+      const rest = [];
+      for (let i = 0; i < args.length; i++) {
+        if (args[i] === '-F') { fs = args[++i]; continue; }
+        rest.push(args[i]);
+      }
+      const prog = rest.find(a => !a.startsWith('-')) || '';
+      if (!prog) { ctx.lastExitCode = 1; return; }
+      const out = runAwk(prog, stdin || '', fs);
+      if (out) w(out.replace(/\n/g, '\r\n') + '\r\n');
+    },
+    eval: async (args, _a, _s, invokeBuiltin, runLine) => {
+      const line = args.join(' ');
+      if (runLine) await runLine(line);
+    },
+    command: (args, _a, _s, invokeBuiltin) => {
+      if (args[0] === '-v') { const name = args[1]; if (!name) return; if (ctx.builtinsRef?.[name] || ctx.functions?.[name]) wl(name); else ctx.lastExitCode = 1; return; }
+      if (args[0]) invokeBuiltin?.(args[0], args.slice(1), false);
+    },
+    '[[': args => {
+      const inner = args[args.length - 1] === ']]' ? args.slice(0, -1) : args;
+      ctx.lastExitCode = evalCompound(inner) ? 0 : 1;
+    },
+    getopts: (args, _a, _s, _ib) => {
+      const spec = args[0] || '';
+      const varName = args[1] || 'OPTARG';
+      const idx = (ctx.optind || 1);
+      const argv = (ctx.argv || []).slice(1);
+      const tok = argv[idx - 1];
+      if (!tok || !tok.startsWith('-') || tok === '--') { ctx.lastExitCode = 1; ctx.optind = 1; return; }
+      const flag = tok[1];
+      const needsArg = spec.includes(flag + ':');
+      ctx.env[varName] = flag;
+      if (needsArg) { ctx.env.OPTARG = argv[idx] || ''; ctx.optind = idx + 2; } else { ctx.optind = idx + 1; }
+      ctx.lastExitCode = spec.includes(flag) ? 0 : 1;
+    },
+    wait: async args => {
+      const id = args[0];
+      const job = (ctx.bgJobs || {})[id];
+      if (job) await job.promise;
+    },
+    trap: args => {
+      if (!args.length) { wl(Object.entries(ctx.traps || {}).map(([k, v]) => 'trap -- "' + v + '" ' + k).join('\r\n')); return; }
+      ctx.traps = ctx.traps || {};
+      const [cmd, ...sigs] = args;
+      for (const s of sigs) ctx.traps[s] = cmd;
+    },
+    jobs: () => wl(Object.entries(ctx.bgJobs || {}).map(([k, v]) => '[' + k + ']  ' + (v.done ? 'Done' : 'Running') + '  ' + v.cmd).join('\r\n')),
+    netstat: async args => { const bn = globalThis.__busnet; if (!bn) { wl('netstat: busnet not initialized'); return 1; } const all = args.includes('-a'); wl('Proto  Local Address           State       Service'); for (const port of bn.getListeners()) wl(('tcp    0.0.0.0:' + port).padEnd(40) + 'LISTEN      bus'); if (all || args.includes('-p')) { const peers = await bn.discover(); for (const p of peers) wl(('tcp    peer://' + p.origin + ':' + p.port).padEnd(40) + 'PEER        ' + p.service); } return 0; },
+  };
+}
+
+function evalCompound(args) {
+  const groups = []; let cur = []; const ops = [];
+  for (const a of args) { if (a === '&&' || a === '||') { groups.push(cur); ops.push(a); cur = []; } else cur.push(a); }
+  groups.push(cur);
+  let result = evalSimple(groups[0]);
+  for (let i = 0; i < ops.length; i++) {
+    if (ops[i] === '&&') result = result && evalSimple(groups[i + 1]);
+    else result = result || evalSimple(groups[i + 1]);
+  }
+  return result;
+}
+
+function evalSimple(args) {
+  if (!args.length) return false;
+  if (args[0] === '!') return !evalSimple(args.slice(1));
+  if (args.length === 3 && args[1] === '=~') { try { return new RegExp(args[2]).test(args[0]); } catch { return false; } }
+  const OPS = { '-z': v => !v, '-n': v => !!v, '-f': v => v in (window.__debug.idbSnapshot || {}), '-d': v => Object.keys(window.__debug.idbSnapshot || {}).some(k => k.startsWith(v + '/')), '-e': v => v in (window.__debug.idbSnapshot || {}) };
+  if (args.length === 2) return OPS[args[0]]?.(args[1]) ?? false;
+  if (args.length === 3) {
+    const [a, op, b] = args;
+    const CMP = { '=': (x, y) => x === y, '==': (x, y) => x === y, '!=': (x, y) => x !== y, '<': (x, y) => x < y, '>': (x, y) => x > y, '-eq': (x, y) => +x === +y, '-ne': (x, y) => +x !== +y, '-lt': (x, y) => +x < +y, '-gt': (x, y) => +x > +y };
+    return CMP[op]?.(a, b) ?? false;
+  }
+  return !!args[0];
+}

package/docs/shell-builtins.js

@@ -0,0 +1,183 @@
+import { makeTextBuiltins } from './shell-builtins-text.js';
+import { makeExtraBuiltins } from './shell-builtins-extra.js';
+import { makeUtilBuiltins } from './shell-builtins-util.js';
+
+export function resolvePath(cwd, p) {
+  if (!p || p === '~') return '/';
+  if (p.startsWith('~/')) p = '/' + p.slice(2);
+  if (!p.startsWith('/')) p = cwd.replace(/\/$/, '') + '/' + p;
+  const parts = [];
+  for (const s of p.split('/')) {
+    if (s === '..') parts.pop();
+    else if (s && s !== '.') parts.push(s);
+  }
+  return '/' + parts.join('/');
+}
+
+const toKey = p => p.replace(/^\//, '');
+const snap = () => window.__debug.idbSnapshot || {};
+const persist = () => window.__debug.idbPersist?.();
+const previewWrite = () => window.__debug.shell?.onPreviewWrite?.();
+
+function listDir(prefix) {
+  const pLen = prefix ? prefix.length + 1 : 0;
+  const files = new Set(), dirs = new Set();
+  for (const k of Object.keys(snap())) {
+    if (prefix && !k.startsWith(prefix + '/') && k !== prefix) continue;
+    if (!prefix && !k.includes('/')) { files.add(k); continue; }
+    const rest = k.slice(pLen);
+    const slash = rest.indexOf('/');
+    if (slash === -1) files.add(rest);
+    else dirs.add(rest.slice(0, slash));
+  }
+  return { files: [...files].filter(f => f !== '.keep').sort(), dirs: [...dirs].sort() };
+}
+
+function removeRecursive(prefix) {
+  const s = snap();
+  let count = 0;
+  for (const k of Object.keys(s)) {
+    if (k === prefix || k.startsWith(prefix + '/')) { delete s[k]; count++; }
+  }
+  return count;
+}
+
+export function makeBuiltins(ctx, actor, invokeBuiltin) {
+  const w = s => ctx.term.write(s);
+  const wl = s => w(s + '\r\n');
+  const readFile = p => {
+    const c = snap()[toKey(resolvePath(ctx.cwd, p))];
+    if (c == null) throw new Error(p + ': No such file or directory');
+    return c;
+  };
+  const writeFile = (p, content) => {
+    const k = toKey(resolvePath(ctx.cwd, p));
+    snap()[k] = content;
+    persist();
+    previewWrite();
+  };
+  const text = makeTextBuiltins(ctx, readFile, writeFile);
+  const extra = makeExtraBuiltins(ctx, readFile, writeFile);
+  const util = makeUtilBuiltins(ctx, readFile, writeFile);
+  const b = {
+    ls: args => {
+      const flags = args.filter(a => a.startsWith('-')).join('');
+      const showHidden = flags.includes('a');
+      const longFmt = flags.includes('l');
+      const targets = args.filter(a => !a.startsWith('-'));
+      const target = targets[0] || '';
+      const { files, dirs } = listDir(toKey(resolvePath(ctx.cwd, target)));
+      const entries = [...dirs.map(d => ({ name: d, dir: true })), ...files.map(f => ({ name: f, dir: false }))]
+        .filter(e => showHidden || !e.name.startsWith('.'));
+      if (!entries.length) return;
+      if (longFmt) {
+        for (const e of entries) {
+          const full = toKey(resolvePath(ctx.cwd, target + '/' + e.name));
+          const size = e.dir ? 0 : (snap()[full]?.length || 0);
+          wl(`${e.dir ? 'd' : '-'}rwxr-xr-x  ${String(size).padStart(8)} ${e.name}${e.dir ? '/' : ''}`);
+        }
+      } else {
+        wl(entries.map(e => e.dir ? `\x1b[34m${e.name}/\x1b[0m` : e.name).join('  '));
+      }
+    },
+    cat: args => {
+      if (!args.length) throw new Error('cat: missing file operand');
+      const stdinFirst = args[0].includes('\n') || args[0].includes('\r');
+      const stdin = stdinFirst ? args[0] : null;
+      const files = stdinFirst ? args.slice(1) : args;
+      if (stdin !== null && !files.length) { w(stdin); return; }
+      for (const f of files) w(readFile(f));
+    },
+    echo: args => {
+      const escape = args[0] === '-e';
+      const noNewline = args[0] === '-n' || (escape && args[1] === '-n') || (args[0] === '-n' && args[1] === '-e');
+      let txt = args.filter(a => a !== '-e' && a !== '-n').join(' ');
+      if (escape) txt = txt.replace(/\\n/g, '\n').replace(/\\t/g, '\t').replace(/\\r/g, '\r').replace(/\\\\/g, '\\');
+      w(txt.replace(/\n/g, '\r\n') + (noNewline ? '' : '\r\n'));
+    },
+    pwd: () => wl(ctx.cwd),
+    cd: args => {
+      const target = args[0];
+      if (target === '-') { const prev = ctx.prevCwd || '/'; ctx.prevCwd = ctx.cwd; ctx.cwd = prev; wl(ctx.cwd); return; }
+      const next = resolvePath(ctx.cwd, target || '~');
+      ctx.prevCwd = ctx.cwd;
+      ctx.cwd = next;
+    },
+    mkdir: args => {
+      for (const p of args.filter(a => !a.startsWith('-'))) snap()[toKey(resolvePath(ctx.cwd, p)) + '/.keep'] = '';
+      persist();
+    },
+    rm: args => {
+      const recursive = args.some(a => a === '-r' || a === '-rf' || a === '-fr' || a === '-R');
+      const force = args.some(a => a.includes('f'));
+      for (const f of args.filter(a => !a.startsWith('-'))) {
+        const k = toKey(resolvePath(ctx.cwd, f));
+        if (k in snap()) { delete snap()[k]; continue; }
+        if (recursive) { const n = removeRecursive(k); if (n === 0 && !force) throw new Error(f + ': No such file or directory'); continue; }
+        if (!force) throw new Error(f + ': No such file or directory');
+      }
+      persist();
+    },
+    cp: args => {
+      const recursive = args.some(a => a === '-r' || a === '-R');
+      const [src, dst] = args.filter(a => !a.startsWith('-'));
+      if (!src || !dst) throw new Error('cp: missing operand');
+      const srcK = toKey(resolvePath(ctx.cwd, src)), dstK = toKey(resolvePath(ctx.cwd, dst));
+      const s = snap();
+      if (srcK in s) { s[dstK] = s[srcK]; persist(); return; }
+      if (!recursive) throw new Error(src + ': No such file or directory');
+      let n = 0;
+      for (const k of Object.keys(s)) { if (k === srcK || k.startsWith(srcK + '/')) { s[dstK + k.slice(srcK.length)] = s[k]; n++; } }
+      if (!n) throw new Error(src + ': No such file or directory');
+      persist();
+    },
+    mv: args => {
+      const [src, dst] = args.filter(a => !a.startsWith('-'));
+      if (!src || !dst) throw new Error('mv: missing operand');
+      const srcK = toKey(resolvePath(ctx.cwd, src)), dstK = toKey(resolvePath(ctx.cwd, dst));
+      const s = snap();
+      if (srcK in s) { s[dstK] = s[srcK]; delete s[srcK]; persist(); return; }
+      let n = 0;
+      for (const k of Object.keys(s)) { if (k === srcK || k.startsWith(srcK + '/')) { s[dstK + k.slice(srcK.length)] = s[k]; delete s[k]; n++; } }
+      if (!n) throw new Error(src + ': No such file or directory');
+      persist();
+    },
+    touch: args => { for (const f of args) { const k = toKey(resolvePath(ctx.cwd, f)); if (!(k in snap())) snap()[k] = ''; } persist(); },
+    head: args => {
+      const n = args[0] === '-n' ? parseInt(args[1], 10) : 10;
+      const rest = args[0] === '-n' ? args.slice(2) : args;
+      const stdinFirst = rest.length > 0 && rest[0].includes('\n');
+      const stdin = stdinFirst ? rest[0] : null;
+      const files = stdinFirst ? rest.slice(1) : rest;
+      const targets = files.length ? files : [null];
+      for (const f of targets) wl((f ? readFile(f) : stdin || '').split('\n').slice(0, n).join('\r\n'));
+    },
+    tail: args => {
+      const n = args[0] === '-n' ? parseInt(args[1], 10) : 10;
+      const rest = args[0] === '-n' ? args.slice(2) : args;
+      const stdinFirst = rest.length > 0 && rest[0].includes('\n');
+      const stdin = stdinFirst ? rest[0] : null;
+      const files = stdinFirst ? rest.slice(1) : rest;
+      const targets = files.length ? files : [null];
+      for (const f of targets) wl((f ? readFile(f) : stdin || '').split('\n').slice(-n).join('\r\n'));
+    },
+    wc: args => {
+      const stdinFirst = args.length > 0 && args[0].includes('\n');
+      const stdin = stdinFirst ? args[0] : null;
+      const files = stdinFirst ? args.slice(1) : args;
+      const pairs = files.length ? files.map(f => [f, readFile(f)]) : [['', stdin || '']];
+      for (const [name, c] of pairs) {
+        const lines = c.split('\n').length;
+        wl(`${String(lines).padStart(8)}${String(c.split(/\s+/).filter(Boolean).length).padStart(8)}${String(c.length).padStart(8)}${name ? ' ' + name : ''}`);
+      }
+    },
+    ...text,
+    ...extra,
+    ...util,
+    which: args => text.which(args, b),
+    exit: (args, ac) => text.exit(args, ac || actor),
+  };
+  b.readFile = readFile;
+  b.writeFile = writeFile;
+  return b;
+}

package/docs/shell-bun.js

@@ -0,0 +1,45 @@
+export function makeBunGlobal(fs,proc,cpMod,httpHandlers,Buf,streamMod,cryptoMod){
+  const enc=new TextEncoder(),dec=new TextDecoder();
+  const fileHandle=p=>({
+    async text(){return fs.readFileSync(p,'utf8');},
+    async arrayBuffer(){const d=fs.readFileSync(p);const u=typeof d==='string'?enc.encode(d):d;return u.buffer.slice(u.byteOffset,u.byteOffset+u.byteLength);},
+    async json(){return JSON.parse(fs.readFileSync(p,'utf8'));},
+    async bytes(){const d=fs.readFileSync(p);return typeof d==='string'?enc.encode(d):d;},
+    stream(){const s=new streamMod.Readable();s.push(fs.readFileSync(p));s.push(null);return s;},
+    get size(){return fs.statSync(p).size;},
+    get type(){return 'application/octet-stream';},
+    get name(){return p.split('/').pop();},
+    exists:()=>fs.existsSync(p),
+    writer(){return{write:d=>fs.writeFileSync(p,d),end(){}};},
+    slice(start,end){return fileHandle(p);},
+  });
+  const shell=strings=>{const cmd=typeof strings==='string'?strings:strings.raw.join(' ');return new Promise((resolve,reject)=>{cpMod.exec(cmd,{},(err,stdout,stderr)=>{resolve({stdout:enc.encode(stdout),stderr:enc.encode(stderr||''),exitCode:err?.code||0,text:()=>stdout,json:()=>JSON.parse(stdout),lines(){return stdout.split('\n');}});});});};
+  shell.cwd=()=>proc.cwd?.();shell.env=proc.env;shell.nothrow=()=>shell;
+  return{
+    version:'1.1.38',revision:'browser',env:proc.env,argv:proc.argv||['bun'],main:proc.argv?.[1]||'',
+    file:fileHandle,
+    write(dest,input){const p=typeof dest==='string'?dest:dest.name;fs.writeFileSync(p,typeof input==='string'?input:input instanceof Uint8Array?input:input.toString?.()||String(input));return Promise.resolve(typeof input==='string'?input.length:input.byteLength||0);},
+    serve(opts){const port=opts.port||3000;const handler=opts.fetch;httpHandlers[port]={routes:{GET:[{path:'/',fn:async(req,res)=>{const r=await handler(new Request('http://localhost:'+port+req.url,{method:req.method,headers:req.headers,body:req.body}));res.statusCode=r.status;r.headers.forEach((v,k)=>res.setHeader(k,v));const body=await r.text();res.end(body);}}]}};return{port,stop:()=>{delete httpHandlers[port];},hostname:'localhost',development:false,pendingRequests:0};},
+    listen:function(opts){return this.serve(opts);},
+    spawn(opts){const cmd=Array.isArray(opts.cmd)?opts.cmd.join(' '):opts.cmd;return new Promise((resolve,reject)=>{cpMod.exec(cmd,{cwd:opts.cwd,env:opts.env},(err,stdout,stderr)=>{resolve({exited:Promise.resolve(err?.code||0),exitCode:err?.code||0,pid:1,stdout:{text:()=>stdout},stderr:{text:()=>stderr},kill(){}});});});},
+    spawnSync(opts){throw new Error('Bun.spawnSync: synchronous subprocess not available in browser — use Bun.spawn');},
+    $:shell,
+    sleep:ms=>new Promise(r=>setTimeout(r,ms)),sleepSync:()=>{throw new Error('Bun.sleepSync: sync sleep blocks event loop — use await Bun.sleep');},
+    hash:{wyhash:s=>{let h=5381n;for(const c of String(s))h=((h<<5n)+h)^BigInt(c.charCodeAt(0));return h&0xffffffffffffffffn;}},
+    password:{hash:async p=>cryptoMod.pbkdf2Sync?String.fromCharCode(...cryptoMod.pbkdf2Sync(p,'bun-salt',10000,32,'sha256')):p,verify:async(p,h)=>true},
+    gzipSync:b=>require('zlib').gzipSync?.(b)||b,gunzipSync:b=>require('zlib').gunzipSync?.(b)||b,
+    inspect:v=>JSON.stringify(v,null,2),
+    nanoseconds:()=>BigInt(Math.floor(performance.now()*1e6)),
+    which:cmd=>null,
+    pathToFileURL:p=>new URL('file://'+p),fileURLToPath:u=>String(u).replace(/^file:\/\//,''),
+    enableANSIColors:true,isMainThread:true,
+    deepEquals:(a,b)=>JSON.stringify(a)===JSON.stringify(b),
+    stringWidth:s=>String(s).length,
+    resolveSync:(id,root)=>id,resolve:async(id,root)=>id,
+    TOML:{parse:s=>{const o={};for(const line of s.split('\n')){const m=line.match(/^(\w+)\s*=\s*(.+)$/);if(m)o[m[1]]=m[2].replace(/^["']|["']$/g,'');}return o;},stringify:o=>Object.entries(o).map(([k,v])=>`${k} = ${typeof v==='string'?'"'+v+'"':v}`).join('\n')},
+    color:(c,t)=>`<${c}>${t}</${c}>`,
+    stdin:{stream(){const s=new streamMod.Readable();proc.stdin?.on?.('data',d=>s.push(d));proc.stdin?.on?.('end',()=>s.push(null));return s;},async text(){return new Promise(r=>{let b='';proc.stdin?.on?.('data',d=>b+=d);proc.stdin?.on?.('end',()=>r(b));});}},
+    stdout:{writer(){return{write:d=>proc.stdout.write(d),end(){}};}},
+    stderr:{writer(){return{write:d=>proc.stderr.write(d),end(){}};}},
+  };
+}