thebird 1.2.78 → 1.2.80

package/docs/shell-control.js

@@ -0,0 +1,132 @@
+export async function runScript(text, run, ctx) {
+  let block = [];
+  for (const s of text.split('\n').flatMap(l => l.split(';')).map(x => x.trim()).filter(Boolean)) {
+    if (block.length || isControlStart(s)) { block.push(s); if (!isBlockOpen(block)) { await runControl(block.slice(), run, ctx); block = []; } continue; }
+    await run(s);
+  }
+}
+
+export function isControlStart(cmd) {
+  const t = cmd.trim();
+  const first = t.split(/\s+/)[0];
+  if (first === 'if' || first === 'while' || first === 'for' || first === 'case' || first === 'until' || first === 'select') return true;
+  if (/^[A-Za-z_][A-Za-z0-9_]*\s*\(\s*\)/.test(t)) return true;
+  return false;
+}
+
+export function isBlockOpen(lines) {
+  const joined = lines.join(' ').trim();
+  let depth = 0;
+  const tokens = joined.split(/\s+/);
+  for (const t of tokens) {
+    if (t === 'if' || t === 'while' || t === 'for' || t === 'case' || t === 'until' || t === 'select') depth++;
+    if (t === 'fi' || t === 'done' || t === 'esac') depth--;
+  }
+  const fnOpen = /\{\s*$/.test(joined) || /\(\s*\)\s*$/.test(joined);
+  const fnClose = /\}\s*$/.test(joined);
+  let braceDepth = 0;
+  let inSingle = false, inDouble = false;
+  for (const ch of joined) {
+    if (ch === "'" && !inDouble) inSingle = !inSingle;
+    else if (ch === '"' && !inSingle) inDouble = !inDouble;
+    else if (!inSingle && !inDouble) {
+      if (ch === '{') braceDepth++;
+      if (ch === '}') braceDepth--;
+    }
+  }
+  return depth > 0 || braceDepth > 0 || (fnOpen && !fnClose);
+}
+
+export async function runControl(block, run, ctx) {
+  const joined = block.join(' ').trim();
+  if (/^[A-Za-z_][A-Za-z0-9_]*\s*\(\s*\)/.test(joined)) return defineFn(joined, ctx);
+  if (joined.startsWith('if ')) return runIf(joined, run, ctx);
+  if (joined.startsWith('while ')) return runWhile(joined, run, ctx, false);
+  if (joined.startsWith('until ')) return runWhile(joined.replace(/^until /, 'while '), run, ctx, true);
+  if (joined.startsWith('for ')) return runFor(joined, run, ctx);
+  if (joined.startsWith('case ')) return runCase(joined, run, ctx);
+  if (joined.startsWith('select ')) return runSelect(joined, run, ctx);
+}
+
+async function runSelect(text, run, ctx) {
+  const m = text.match(/^select\s+(\w+)\s+in\s+(.+?)\s*;\s*do\s+(.+?)\s*;\s*done$/s);
+  if (!m) throw new Error('select: parse error: ' + text);
+  const [, varName, listExpr, body] = m;
+  const items = listExpr.split(/\s+/).filter(Boolean);
+  for (let i = 0; i < items.length; i++) ctx.term.write((i + 1) + ') ' + items[i] + '\r\n');
+  for (const it of items) { ctx.env[varName] = it; await run(body); if (ctx.loopFlag === 'break') { ctx.loopFlag = null; break; } }
+}
+
+function defineFn(text, ctx) {
+  const m = text.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*\(\s*\)\s*\{?\s*(.+?)\s*\}?\s*$/s);
+  if (!m) throw new Error('function: parse error: ' + text);
+  const [, name, body] = m;
+  ctx.functions = ctx.functions || {};
+  ctx.functions[name] = body.replace(/^\{\s*/, '').replace(/\s*\}$/, '').trim();
+}
+
+async function runIf(text, run, ctx) {
+  const body = text.replace(/^if\s+/, '').replace(/\s*;\s*fi$/, '');
+  const parts = body.split(/\s*;\s*(?=then|elif|else)\s*/);
+  const branches = [];
+  let i = 0;
+  while (i < parts.length) {
+    if (parts[i] === 'then' || parts[i] === 'elif' || parts[i] === 'else') { i++; continue; }
+    if (parts[i - 1] === 'else') { branches.push({ cond: null, body: parts[i] }); i++; continue; }
+    const cond = parts[i]; const bodyPart = parts[i + 2] || parts[i + 1];
+    branches.push({ cond, body: bodyPart });
+    i += (parts[i + 1] === 'then' ? 3 : 2);
+  }
+  for (const br of branches) {
+    if (br.cond === null) { await run(br.body); return; }
+    await run(br.cond);
+    if (ctx.lastExitCode === 0) { await run(br.body); return; }
+  }
+}
+
+async function runWhile(text, run, ctx, invert) {
+  const m = text.match(/^while\s+(.+?)\s*;\s*do\s+(.+?)\s*;\s*done$/s);
+  if (!m) throw new Error('while: parse error: ' + text);
+  const [, cond, body] = m;
+  let guard = 0;
+  ctx.loopFlag = null;
+  while (guard++ < 10000) {
+    await run(cond);
+    const ok = ctx.lastExitCode === 0;
+    if ((invert ? ok : !ok)) break;
+    await run(body);
+    if (ctx.loopFlag === 'break') { ctx.loopFlag = null; break; }
+    if (ctx.loopFlag === 'continue') ctx.loopFlag = null;
+  }
+}
+
+async function runFor(text, run, ctx) {
+  const m = text.match(/^for\s+(\w+)\s+in\s+(.+?)\s*;\s*do\s+(.+?)\s*;\s*done$/s);
+  if (!m) throw new Error('for: parse error: ' + text);
+  const [, varName, listExpr, body] = m;
+  const items = listExpr.split(/\s+/).filter(Boolean);
+  ctx.loopFlag = null;
+  for (const item of items) {
+    ctx.env[varName] = item;
+    await run(body);
+    if (ctx.loopFlag === 'break') { ctx.loopFlag = null; break; }
+    if (ctx.loopFlag === 'continue') { ctx.loopFlag = null; continue; }
+  }
+}
+
+async function runCase(text, run, ctx) {
+  const m = text.match(/^case\s+(.+?)\s+in\s+(.+?)\s*;\s*esac$/s);
+  if (!m) throw new Error('case: parse error: ' + text);
+  const [, subject, body] = m;
+  const sub = (ctx.expand ? ctx.expand(subject) : subject).trim();
+  const clauses = body.split(/\s*;;\s*/).filter(Boolean);
+  for (const clause of clauses) {
+    const cm = clause.match(/^(.+?)\)\s*(.+)$/s);
+    if (!cm) continue;
+    const [, patterns, cmds] = cm;
+    for (const pat of patterns.split('|').map(s => s.trim())) {
+      const re = new RegExp('^' + pat.replace(/[-[\]{}()+.,\\^$|#]/g, '\\$&').replace(/\*/g, '.*').replace(/\?/g, '.') + '$');
+      if (re.test(sub)) { await run(cmds); return; }
+    }
+  }
+}

package/docs/shell-deno.js

@@ -0,0 +1,54 @@
+export function makeDenoGlobal(fs,proc,cpMod,httpHandlers,Buf){
+  const enc=new TextEncoder(),dec=new TextDecoder();
+  const readFile=async p=>fs.existsSync(p)?(typeof fs.readFileSync(p)==='string'?enc.encode(fs.readFileSync(p)):fs.readFileSync(p)):(()=>{const e=new Error('NotFound: '+p);e.code='ENOENT';throw e;})();
+  return{
+    version:{deno:'2.0.0',v8:'12.9.202',typescript:'5.6.0'},
+    build:{target:'x86_64-unknown-linux-gnu',arch:'x86_64',os:'linux',vendor:'unknown'},
+    pid:proc.pid||1,ppid:0,hostname:()=>'thebird',
+    cwd:()=>proc.cwd?.()||'/',
+    chdir:p=>proc.chdir?.(p),
+    exit:code=>proc.exit(code||0),
+    env:{get:k=>proc.env[k],set:(k,v)=>{proc.env[k]=v;},delete:k=>{delete proc.env[k];},has:k=>k in proc.env,toObject:()=>({...proc.env})},
+    args:(proc.argv||[]).slice(2),
+    execPath:()=>'/usr/local/bin/deno',
+    readTextFile:async p=>{const d=await readFile(p);return typeof d==='string'?d:dec.decode(d);},
+    readTextFileSync:p=>fs.readFileSync(p,'utf8'),
+    readFile,
+    readFileSync:p=>{const d=fs.readFileSync(p);return typeof d==='string'?enc.encode(d):d;},
+    writeTextFile:async(p,d)=>fs.writeFileSync(p,d),
+    writeTextFileSync:(p,d)=>fs.writeFileSync(p,d),
+    writeFile:async(p,d)=>fs.writeFileSync(p,d),
+    writeFileSync:(p,d)=>fs.writeFileSync(p,d),
+    mkdir:async(p,opts)=>fs.mkdirSync(p,opts),
+    mkdirSync:(p,opts)=>fs.mkdirSync(p,opts),
+    remove:async(p,opts)=>{if(opts?.recursive)fs.rmSync(p,{recursive:true});else fs.unlinkSync(p);},
+    removeSync:(p,opts)=>{if(opts?.recursive)fs.rmSync(p,{recursive:true});else fs.unlinkSync(p);},
+    rename:async(o,n)=>fs.renameSync(o,n),
+    renameSync:(o,n)=>fs.renameSync(o,n),
+    stat:async p=>fs.statSync(p),
+    statSync:p=>fs.statSync(p),
+    lstat:async p=>fs.lstatSync?.(p)||fs.statSync(p),
+    lstatSync:p=>fs.lstatSync?.(p)||fs.statSync(p),
+    symlink:async(t,l)=>fs.symlinkSync?.(t,l),
+    symlinkSync:(t,l)=>fs.symlinkSync?.(t,l),
+    realPath:async p=>fs.realpathSync?.(p)||p,
+    realPathSync:p=>fs.realpathSync?.(p)||p,
+    readDir:async function*(p){for(const name of fs.readdirSync(p))yield{name,isFile:true,isDirectory:false,isSymlink:false};},
+    readDirSync:function*(p){for(const name of fs.readdirSync(p))yield{name,isFile:true,isDirectory:false,isSymlink:false};},
+    makeTempDir:async opts=>fs.mkdtempSync?.((opts?.prefix||'/tmp/deno-'))||'/tmp/deno-'+Math.random().toString(36).slice(2,8),
+    makeTempFile:async opts=>{const p=(opts?.prefix||'/tmp/')+'deno-'+Math.random().toString(36).slice(2,8);fs.writeFileSync(p,'');return p;},
+    serve(opts,handler){const h=typeof opts==='function'?opts:handler||opts.fetch;const port=opts.port||8000;httpHandlers[port]={routes:{GET:[{path:'/',fn:async(req,res)=>{const r=await h(new Request('http://localhost:'+port+req.url,{method:req.method,headers:req.headers}));res.statusCode=r.status;r.headers.forEach((v,k)=>res.setHeader(k,v));res.end(await r.text());}}]}};return{shutdown:async()=>{delete httpHandlers[port];},finished:Promise.resolve()};},
+    Command:class{constructor(cmd,opts={}){this.cmd=cmd;this.opts=opts;}async output(){return new Promise((resolve,reject)=>{cpMod.exec([this.cmd,...(this.opts.args||[])].join(' '),{cwd:this.opts.cwd,env:this.opts.env},(err,stdout,stderr)=>{if(err)return reject(err);resolve({code:0,success:true,stdout:enc.encode(stdout),stderr:enc.encode(stderr)});});});}spawn(){return this;}},
+    permissions:{query:async d=>({state:'granted',onchange:null,partial:false}),request:async d=>({state:'granted'}),revoke:async d=>({state:'prompt'})},
+    errors:{NotFound:class extends Error{constructor(m){super(m);this.name='NotFound';}},PermissionDenied:class extends Error{constructor(m){super(m);this.name='PermissionDenied';}},AlreadyExists:class extends Error{constructor(m){super(m);this.name='AlreadyExists';}}},
+    inspect:v=>JSON.stringify(v,null,2),
+    noColor:false,isatty:()=>true,
+    addSignalListener(sig,fn){proc.on(sig,fn);},removeSignalListener(sig,fn){proc.off?.(sig,fn);},
+    stdin:{readable:new ReadableStream({start(c){proc.stdin?.on?.('data',d=>c.enqueue(typeof d==='string'?new TextEncoder().encode(d):d));proc.stdin?.on?.('end',()=>c.close());}}),readSync(){return 0;},read:async buf=>0,rid:0,isTerminal:()=>!!proc.stdin?.isTTY},
+    stdout:{writable:new WritableStream({write(c){proc.stdout.write(typeof c==='string'?c:new TextDecoder().decode(c));}}),writeSync:d=>{proc.stdout.write(typeof d==='string'?d:new TextDecoder().decode(d));return d.length;},write:async d=>d.length,rid:1,isTerminal:()=>!!proc.stdout?.isTTY},
+    stderr:{writable:new WritableStream({write(c){proc.stderr.write(typeof c==='string'?c:new TextDecoder().decode(c));}}),writeSync:d=>{proc.stderr.write(typeof d==='string'?d:new TextDecoder().decode(d));return d.length;},write:async d=>d.length,rid:2,isTerminal:()=>!!proc.stderr?.isTTY},
+    memoryUsage:()=>proc.memoryUsage(),
+    resources:()=>({}),close:rid=>{},
+    refTimer:t=>t?.ref?.(),unrefTimer:t=>t?.unref?.(),
+  };
+}

package/docs/shell-exec.js

@@ -0,0 +1,85 @@
+import { registerStream, readStream } from './shell-procsub.js';
+import { tokenize, globToRe } from './shell-parser.js';
+import { fullExpand, expandBraces, expandTilde } from './shell-expand.js';
+import { resolvePath } from './shell-builtins.js';
+import { NODE_VERSION } from './shell-node-modules.js';
+
+export function makeExpander(ctx, captureRun, parseRedirect) {
+  const toKey = p => p.replace(/^\//, '');
+  const snap = () => window.__debug.idbSnapshot || {};
+
+  function replaceProcSub(token) {
+    let out = ''; let i = 0;
+    while (i < token.length) {
+      if ((token[i] === '<' || token[i] === '>') && token[i + 1] === '(') {
+        let depth = 1; let j = i + 2;
+        while (j < token.length && depth > 0) { if (token[j] === '(') depth++; else if (token[j] === ')') depth--; if (depth) j++; }
+        if (depth === 0) { out += registerStream(captureRun(token.slice(i + 2, j))); i = j + 1; continue; }
+      }
+      out += token[i++];
+    }
+    return out;
+  }
+
+  function expandGlob(token) {
+    if (!token.includes('*') && !token.includes('?') && !token.includes('[')) return [token];
+    const prefix = toKey(resolvePath(ctx.cwd, ''));
+    const keys = Object.keys(snap()).map(k => prefix && k.startsWith(prefix + '/') ? k.slice(prefix.length + 1) : k);
+    const re = globToRe(token);
+    const matches = keys.filter(k => re.test(k));
+    return matches.length ? matches.sort() : [token];
+  }
+
+  function expandTokens(tokens) {
+    return tokens.flatMap(t => {
+      const procsub = t.includes('<(') || t.includes('>(') ? replaceProcSub(t) : t;
+      const tilde = expandTilde(procsub, ctx.env);
+      const braces = expandBraces(tilde);
+      return braces.flatMap(b => expandGlob(fullExpand(b, ctx.env, ctx.lastExitCode, ctx.argv, captureRun, ctx.arrays)));
+    });
+  }
+  return { expandTokens, expandGlob, replaceProcSub };
+}
+
+export function makeCaptureRun(ctx, BUILTINS, actor, parseRedirect, expandTokens) {
+  return function captureRun(line) {
+    const raw = tokenize(line); if (!raw.length) return '';
+    let out = ''; const orig = ctx.term.write.bind(ctx.term); ctx.term.write = s => { out += s; };
+    try { const [cmd, ...args] = parseRedirect(expandTokens(raw)).args; BUILTINS[cmd]?.(args, actor); } finally { ctx.term.write = orig; }
+    return out.replace(/\r\n/g, '\n').replace(/\r/g, '\n').trim();
+  };
+}
+
+const NODE_HELP = 'Usage: node [options] [script.js] [arguments]\r\n  -v, --version   print Node.js version\r\n  -e, --eval      evaluate script\r\n  -p, --print     evaluate and print result\r\n  -h, --help      print this help\r\n';
+
+export function makeNodeRunner(ctx, actor) {
+  const toKey = p => p.replace(/^\//, '');
+  const snap = () => window.__debug.idbSnapshot || {};
+  return async function runNode(args, stdinBuf) {
+    const term = ctx.term;
+    if (!args.length) { actor.send({ type: 'ENTER_REPL' }); term.write('Welcome to Node.js ' + NODE_VERSION + '.\r\nType ".help" for more information.\r\n> '); return; }
+    const a0 = args[0];
+    if (a0 === '-v' || a0 === '--version') { term.write(NODE_VERSION + '\r\n'); return; }
+    if (a0 === '-h' || a0 === '--help') { term.write(NODE_HELP); return; }
+    if (a0 === '-e' || a0 === '--eval') { await ctx.nodeEval(args.slice(1).join(' '), null, [], stdinBuf); return; }
+    if (a0 === '-p' || a0 === '--print') { await ctx.nodeEval('process.stdout.write(String(' + args.slice(1).join(' ') + ') + "\\n")', null, [], stdinBuf); return; }
+    const code = snap()[toKey(resolvePath(ctx.cwd, a0))];
+    if (code == null) { term.write('\x1b[31mnode: ' + a0 + ': No such file or directory\x1b[0m\r\n'); ctx.lastExitCode = 1; return; }
+    actor.send({ type: 'NODE_START' }); ctx.argv = args;
+    try { await ctx.nodeEval(code, a0, args.slice(1), stdinBuf); } finally { ctx.argv = []; }
+  };
+}
+
+export function makeNpmResultRunner(ctx, run) {
+  return async function runNpmResult(r) {
+    if (!r) return;
+    if (r.runInShell) { await run(r.runInShell); return; }
+    if (!r.npmChain) return;
+    for (const step of r.npmChain) {
+      ctx.term.write('\r\n> ' + r.pkgName + '@' + r.pkgVersion + ' ' + step.name + '\r\n> ' + step.cmd + '\r\n\r\n');
+      ctx.env.npm_lifecycle_event = step.name;
+      await run(step.cmd);
+      if (ctx.lastExitCode !== 0) return;
+    }
+  };
+}

package/docs/shell-expand.js

@@ -0,0 +1,164 @@
+export function expandParam(name, env, argv, lastExit, arrays) {
+  if (name === '?') return String(lastExit ?? 0);
+  if (name === '!') return env['!'] || '';
+  if (name === '$') return env.$ || '0';
+  if (name === '#') return String((argv || []).length > 0 ? (argv || []).length - 1 : 0);
+  if (name === '@' || name === '*') return (argv || []).slice(1).join(' ');
+  if (name === '0') return (argv || [])[0] || '';
+  if (/^[1-9]$/.test(name)) return (argv || [])[parseInt(name)] || '';
+  const arrM = name.match(/^([A-Za-z_][A-Za-z0-9_]*)\[(.+?)\]$/);
+  if (arrM && arrays) {
+    const a = arrays[arrM[1]];
+    if (a == null) return '';
+    if (arrM[2] === '@' || arrM[2] === '*') return Array.isArray(a) ? a.join(' ') : Object.values(a).join(' ');
+    if (Array.isArray(a)) return a[parseInt(arrM[2], 10)] || '';
+    return a[arrM[2]] || '';
+  }
+  const lenArrM = name.match(/^#([A-Za-z_][A-Za-z0-9_]*)\[@\]$/);
+  if (lenArrM && arrays) { const a = arrays[lenArrM[1]] || []; return String(Array.isArray(a) ? a.length : Object.keys(a).length); }
+  return env[name] ?? '';
+}
+
+export function expandParamOp(expr, env, argv, lastExit, arrays) {
+  if (expr.startsWith('!')) {
+    const prefM = expr.match(/^!([A-Za-z_]\w*)([@*])$/);
+    if (prefM) return Object.keys(env).filter(k => k.startsWith(prefM[1])).join(' ');
+    const keysM = expr.match(/^!([A-Za-z_]\w*)\[[@*]\]$/);
+    if (keysM && arrays) { const a = arrays[keysM[1]] || []; return Array.isArray(a) ? a.map((_, i) => i).join(' ') : Object.keys(a).join(' '); }
+    const indM = expr.match(/^!([A-Za-z_]\w*)$/);
+    if (indM) { const t = env[indM[1]]; return t ? expandParam(t, env, argv, lastExit, arrays) : ''; }
+  }
+  const caseM = expr.match(/^([A-Za-z_][A-Za-z0-9_]*|@)(\^\^|,,|\^|,)(.*)$/s);
+  if (caseM) {
+    const v = expandParam(caseM[1], env, argv, lastExit, arrays);
+    const op = caseM[2];
+    if (op === '^^') return v.toUpperCase();
+    if (op === ',,') return v.toLowerCase();
+    if (op === '^') return v.charAt(0).toUpperCase() + v.slice(1);
+    if (op === ',') return v.charAt(0).toLowerCase() + v.slice(1);
+  }
+  const qM = expr.match(/^([A-Za-z_][A-Za-z0-9_]*|@)@([QEP])$/);
+  if (qM) {
+    const v = expandParam(qM[1], env, argv, lastExit, arrays);
+    if (qM[2] === 'Q') return "'" + v.replace(/'/g, "'\\''") + "'";
+    if (qM[2] === 'E') return v.replace(/\\n/g, '\n').replace(/\\t/g, '\t');
+    if (qM[2] === 'P') return v;
+  }
+  const lenArrM = expr.match(/^#([A-Za-z_]\w*)\[[@*]\]$/);
+  if (lenArrM) { const a = (arrays || {})[lenArrM[1]] || []; return String(Array.isArray(a) ? a.length : Object.keys(a).length); }
+  const lenM = expr.match(/^#(.+)$/);
+  if (lenM) return String(expandParam(lenM[1], env, argv, lastExit, arrays).length);
+  const sliceM = expr.match(/^([^:]+):(\d+)(?::(\d+))?$/);
+  if (sliceM) { const v = expandParam(sliceM[1], env, argv, lastExit, arrays); const s = +sliceM[2]; return sliceM[3] !== undefined ? v.slice(s, s + (+sliceM[3])) : v.slice(s); }
+  const defM = expr.match(/^([A-Za-z_][A-Za-z0-9_]*|\?|#|@|[0-9])(:-|:=|:\?|:\+|-|=|\+)(.*)$/s);
+  if (defM) {
+    const [, name, op, def] = defM;
+    const v = expandParam(name, env, argv, lastExit, arrays);
+    const defined = v !== '' && v != null;
+    if (op === ':-' || op === '-') return defined ? v : def;
+    if (op === ':=' || op === '=') { if (!defined) env[name] = def; return defined ? v : def; }
+    if (op === ':?' || op === '?') { if (!defined) throw new Error(name + ': ' + (def || 'parameter null')); return v; }
+    if (op === ':+' || op === '+') return defined ? def : '';
+  }
+  const sufM = expr.match(/^([A-Za-z_][A-Za-z0-9_]*|@|#)(%%?|##?)(.+)$/s);
+  if (sufM) {
+    const [, name, op, pat] = sufM;
+    const v = expandParam(name, env, argv, lastExit, arrays);
+    const bare = globReLine(pat).replace(/^\^|\$$/g, '');
+    if (op === '#') { const m = v.match(new RegExp('^' + bare)); return m ? v.slice(m[0].length) : v; }
+    if (op === '##') { const m = v.match(new RegExp('^' + bare.replace(/\.\*/g, '.*?') + '.*')); return m ? '' : v; }
+    if (op === '%') { const m = v.match(new RegExp(bare + '$')); return m ? v.slice(0, -m[0].length) : v; }
+    if (op === '%%') { const m = v.match(new RegExp('^.*' + bare + '$')); return m ? '' : v; }
+  }
+  const subM = expr.match(/^([A-Za-z_][A-Za-z0-9_]*|@)\/(\/?)(.+?)\/(.*)$/s);
+  if (subM) {
+    const [, name, all, pat, rep] = subM;
+    const v = expandParam(name, env, argv, lastExit, arrays);
+    return v.replace(new RegExp(globReLine(pat).replace(/^\^|\$$/g, ''), all ? 'g' : ''), rep);
+  }
+  return expandParam(expr, env, argv, lastExit, arrays);
+}
+
+function globReLine(pat) { return '^' + pat.replace(/[-[\]{}()+.,\\^$|#]/g, (c) => (c === '*' || c === '?') ? c : '\\' + c).replace(/\*/g, '.*').replace(/\?/g, '.') + '$'; }
+
+export function evalArith(expr, env) {
+  const src = expr.replace(/\b([A-Za-z_][A-Za-z0-9_]*)\b/g, (_, n) => String(parseInt(env[n], 10) || 0));
+  if (!/^[-+*/%()<>=!&|\s\d?:]+$/.test(src)) return 0;
+  try { return Function('"use strict"; return (' + src + ')')() | 0; } catch { return 0; }
+}
+
+export function expandBraces(token) {
+  const listM = token.match(/^(.*?)\{([^{}]*,[^{}]*)\}(.*)$/s);
+  if (listM) {
+    const [, pre, list, post] = listM;
+    return list.split(',').flatMap(p => expandBraces(pre + p + post));
+  }
+  const rangeM = token.match(/^(.*?)\{(-?\d+)\.\.(-?\d+)(?:\.\.(-?\d+))?\}(.*)$/s);
+  if (rangeM) {
+    const [, pre, a, b, step, post] = rangeM;
+    const s = step ? +step : ((+a) <= (+b) ? 1 : -1);
+    const out = [];
+    for (let i = +a; s > 0 ? i <= +b : i >= +b; i += s) out.push(i);
+    return out.flatMap(i => expandBraces(pre + i + post));
+  }
+  return [token];
+}
+
+export function expandTilde(token, env) {
+  if (token === '~') return env.HOME || '/';
+  if (token.startsWith('~/')) return (env.HOME || '') + token.slice(1);
+  const m = token.match(/^~([A-Za-z_][A-Za-z0-9_]*)(\/.*)?$/);
+  if (m) return '/home/' + m[1] + (m[2] || '');
+  return token;
+}
+
+export function fullExpand(token, env, lastExit, argv, runCap, arrays) {
+  let out = '';
+  let i = 0;
+  while (i < token.length) {
+    if (token[i] === '`') {
+      const end = token.indexOf('`', i + 1);
+      if (end < 0) { out += token.slice(i); break; }
+      out += runCap ? runCap(token.slice(i + 1, end)) : '';
+      i = end + 1; continue;
+    }
+    if (token[i] === '$' && token[i + 1] === '(' && token[i + 2] === '(') {
+      const close = token.indexOf('))', i + 3);
+      if (close < 0) { out += token[i++]; continue; }
+      out += String(evalArith(token.slice(i + 3, close), env));
+      i = close + 2; continue;
+    }
+    if (token[i] === '$' && token[i + 1] === '(') {
+      const end = findMatch(token, i + 1, '(', ')');
+      if (end < 0) { out += token[i++]; continue; }
+      out += runCap ? runCap(token.slice(i + 2, end)) : '';
+      i = end + 1; continue;
+    }
+    if (token[i] === '$' && token[i + 1] === '{') {
+      const end = token.indexOf('}', i + 2);
+      if (end < 0) { out += token[i++]; continue; }
+      out += expandParamOp(token.slice(i + 2, end), env, argv, lastExit, arrays);
+      i = end + 1; continue;
+    }
+    if (token[i] === '$') {
+      const m = token.slice(i + 1).match(/^(\?|!|#|@|\*|[0-9]|[A-Za-z_][A-Za-z0-9_]*)/);
+      if (m) { out += expandParam(m[1], env, argv, lastExit, arrays); i += 1 + m[1].length; continue; }
+    }
+    out += token[i++];
+  }
+  return out;
+}
+
+function findMatch(s, start, open, close) {
+  let depth = 0; let inSingle = false, inDouble = false;
+  for (let i = start; i < s.length; i++) {
+    const c = s[i];
+    if (c === "'" && !inDouble) inSingle = !inSingle;
+    else if (c === '"' && !inSingle) inDouble = !inDouble;
+    else if (!inSingle && !inDouble) {
+      if (c === open) depth++;
+      else if (c === close) { depth--; if (depth === 0) return i; }
+    }
+  }
+  return -1;
+}

package/docs/shell-fd.js

@@ -0,0 +1,86 @@
+export function createFdTable(ctx) {
+  const table = { 0: { kind: 'stdin', data: '' }, 1: { kind: 'stdout' }, 2: { kind: 'stderr' } };
+  ctx.fds = table;
+
+  function open(fd, source, mode) {
+    const n = parseInt(fd, 10);
+    if (isNaN(n)) throw new Error('fd: invalid: ' + fd);
+    table[n] = { kind: 'file', path: source, mode: mode || 'r', buf: '' };
+    return n;
+  }
+
+  function close(fd) {
+    const n = parseInt(fd, 10);
+    delete table[n];
+  }
+
+  function dup2(src, dst) {
+    const s = parseInt(src, 10);
+    const d = parseInt(dst, 10);
+    if (!table[s]) throw new Error('fd: ' + src + ': bad descriptor');
+    table[d] = { ...table[s], duped: s };
+  }
+
+  function readFd(fd) {
+    const n = parseInt(fd, 10);
+    const slot = table[n];
+    if (!slot) throw new Error('fd ' + fd + ' not open');
+    if (slot.kind === 'stdin') return slot.data || '';
+    if (slot.kind === 'file') {
+      const snap = window.__debug?.idbSnapshot || {};
+      return snap[slot.path.replace(/^\//, '')] || '';
+    }
+    return slot.buf || '';
+  }
+
+  function writeFd(fd, data) {
+    const n = parseInt(fd, 10);
+    const slot = table[n];
+    if (!slot) throw new Error('fd ' + fd + ' not open');
+    if (slot.kind === 'stdout' || n === 1) ctx.term.write(data.replace(/\n/g, '\r\n'));
+    else if (slot.kind === 'stderr' || n === 2) ctx.term.write('\x1b[31m' + data.replace(/\n/g, '\r\n') + '\x1b[0m');
+    else if (slot.kind === 'file') {
+      const snap = window.__debug?.idbSnapshot || (window.__debug.idbSnapshot = {});
+      const k = slot.path.replace(/^\//, '');
+      snap[k] = slot.mode === 'a' ? (snap[k] || '') + data : data;
+      window.__debug?.idbPersist?.();
+    } else { slot.buf = (slot.buf || '') + data; }
+  }
+
+  return { table, open, close, dup2, readFd, writeFd };
+}
+
+export function parseFdRedirects(tokens) {
+  const out = { args: [], redirs: [] };
+  for (let i = 0; i < tokens.length; i++) {
+    const t = tokens[i];
+    const m = t.match(/^(\d+)?(>>|>|<|>&|<&)(\d+)?$/);
+    if (m) {
+      const from = m[1] != null ? +m[1] : (m[2].includes('<') ? 0 : 1);
+      const op = m[2];
+      const toNum = m[3] != null ? +m[3] : null;
+      if (op === '>&' || op === '<&') { out.redirs.push({ kind: 'dup', fd: from, target: toNum }); continue; }
+      const target = tokens[++i];
+      out.redirs.push({ kind: op === '<' ? 'read' : 'write', fd: from, path: target, append: op === '>>' });
+      continue;
+    }
+    out.args.push(t);
+  }
+  return out;
+}
+
+export function makeExecBuiltin(ctx, fdTable) {
+  return args => {
+    if (!args.length) return;
+    for (const a of args) {
+      const m = a.match(/^(\d+)>(>?)(.+)$/);
+      if (m) { fdTable.open(m[1], m[3], m[2] === '>' ? 'a' : 'w'); continue; }
+      const r = a.match(/^(\d+)<(.+)$/);
+      if (r) { fdTable.open(r[1], r[2], 'r'); continue; }
+      const d = a.match(/^(\d+)>&(\d+)$/);
+      if (d) { fdTable.dup2(d[2], d[1]); continue; }
+      const c = a.match(/^(\d+)>&-$/);
+      if (c) { fdTable.close(c[1]); continue; }
+    }
+  };
+}

package/docs/shell-jobs.js

@@ -0,0 +1,86 @@
+import { createMachine, createActor } from './vendor/xstate.js';
+
+const jobMachine = createMachine({
+  id: 'job', initial: 'running',
+  states: {
+    running: { on: { STOP: 'stopped', DONE: 'done', FAIL: 'failed', SIGNAL: { actions: 'deliverSignal' } } },
+    stopped: { on: { CONT: 'running', DONE: 'done', SIGNAL: { actions: 'deliverSignal' } } },
+    done: { type: 'final' },
+    failed: { type: 'final' },
+  },
+});
+
+export function createJobRegistry(ctx) {
+  ctx.bgJobs = ctx.bgJobs || {};
+  let nextId = 1;
+
+  function spawnJob(cmd, runPipeline) {
+    const id = String(nextId++);
+    const actor = createActor(jobMachine.provide({
+      actions: {
+        deliverSignal: (_, ev) => {
+          if (ev?.sig && ctx.signals) ctx.signals.raise(ev.sig);
+        },
+      },
+    }));
+    actor.start();
+    const job = { id, cmd, actor, done: false, stopped: false, killed: false, startedAt: Date.now() };
+    const p = (async () => {
+      try { await runPipeline(cmd); job.exit = ctx.lastExitCode; actor.send({ type: 'DONE' }); }
+      catch (e) { job.error = e.message; actor.send({ type: 'FAIL' }); }
+      finally { job.done = true; }
+    })();
+    job.promise = p;
+    ctx.bgJobs[id] = job;
+    if (ctx.swJobs) ctx.swJobs.register(id, cmd).catch(() => {});
+    return id;
+  }
+
+  function list() {
+    return Object.values(ctx.bgJobs).map(j => ({ id: j.id, cmd: j.cmd, state: j.actor?.getSnapshot().value || 'unknown', done: j.done, stopped: j.stopped }));
+  }
+
+  function resolve(ref) {
+    const id = ref.startsWith('%') ? ref.slice(1) : ref;
+    if (id === '+' || !id) { const keys = Object.keys(ctx.bgJobs); return ctx.bgJobs[keys[keys.length - 1]]; }
+    return ctx.bgJobs[id];
+  }
+
+  return { spawnJob, list, resolve };
+}
+
+export function makeJobsBuiltin(ctx, registry) {
+  return args => {
+    const long = args.includes('-l');
+    for (const j of registry.list()) ctx.term.write('[' + j.id + ']  ' + (j.stopped ? 'Stopped' : j.done ? 'Done' : 'Running') + (long ? '  ' + j.id : '') + '  ' + j.cmd + '\r\n');
+  };
+}
+
+export function makeFgBuiltin(ctx, registry) {
+  return async args => {
+    const job = registry.resolve(args[0] || '+');
+    if (!job) { ctx.term.write('fg: no such job\r\n'); ctx.lastExitCode = 1; return; }
+    if (job.stopped) { job.actor.send({ type: 'CONT' }); job.stopped = false; }
+    ctx.currentJob = job;
+    try { await job.promise; } finally { ctx.currentJob = null; }
+    ctx.lastExitCode = job.exit ?? (job.error ? 1 : 0);
+  };
+}
+
+export function makeBgBuiltin(ctx, registry) {
+  return args => {
+    const job = registry.resolve(args[0] || '+');
+    if (!job) { ctx.term.write('bg: no such job\r\n'); ctx.lastExitCode = 1; return; }
+    if (job.stopped) { job.actor.send({ type: 'CONT' }); job.stopped = false; }
+    ctx.term.write('[' + job.id + ']+ ' + job.cmd + ' &\r\n');
+  };
+}
+
+export function makeDisownBuiltin(ctx) {
+  return args => {
+    for (const a of args) {
+      const id = a.startsWith('%') ? a.slice(1) : a;
+      if (ctx.bgJobs[id]) { ctx.bgJobs[id].disowned = true; delete ctx.bgJobs[id]; }
+    }
+  };
+}