thebird 1.2.79 → 1.2.80

package/docs/shell-parser.js

@@ -0,0 +1,122 @@
+export function tokenize(line) {
+  const tokens = [];
+  let cur = '';
+  let quote = null;
+  let escape = false;
+  for (let i = 0; i < line.length; i++) {
+    const c = line[i];
+    if (escape) {
+      if (quote === '"' && !'"\\`$'.includes(c)) cur += '\\';
+      cur += c; escape = false; continue;
+    }
+    if (c === '\\' && quote !== "'") { escape = true; continue; }
+    if (quote) {
+      if (c === quote) { quote = null; continue; }
+      cur += c;
+      continue;
+    }
+    if (c === '"' || c === "'") { quote = c; continue; }
+    if (/\s/.test(c)) {
+      if (cur) { tokens.push(cur); cur = ''; }
+      continue;
+    }
+    cur += c;
+  }
+  if (cur) tokens.push(cur);
+  return tokens;
+}
+
+export function expand(token, env, lastExitCode, argv) {
+  return token.replace(/\$\(([^)]+)\)|\$\{?(\?|#|@|[0-9]|[A-Za-z_][A-Za-z0-9_]*)\}?/g, (match, sub, name) => {
+    if (sub) return match;
+    if (name === '?') return String(lastExitCode ?? 0);
+    if (name === '#') return String((argv || []).length);
+    if (name === '@') return (argv || []).join(' ');
+    if (name === '0') return (argv || [])[0] || '';
+    if (/^[1-9]$/.test(name)) return (argv || [])[parseInt(name)] || '';
+    return env[name] ?? '';
+  });
+}
+
+export function expandCmdSub(token, env, lastExitCode, runCapture, argv) {
+  if (!token.includes('$(')) return expand(token, env, lastExitCode, argv);
+  return token.replace(/\$\(([^)]+)\)/g, (_, cmd) => runCapture ? runCapture(cmd) : '');
+}
+
+export function parsePipeline(line) {
+  const chunks = splitTopLevel(line, ['&&', '||', ';']);
+  return chunks;
+}
+
+export function splitTopLevel(line, seps) {
+  const cmds = [];
+  const separators = [];
+  let cur = '';
+  let quote = null;
+  let escape = false;
+  for (let i = 0; i < line.length; i++) {
+    const c = line[i];
+    if (escape) { cur += c; escape = false; continue; }
+    if (c === '\\' && quote !== "'") { cur += c; escape = true; continue; }
+    if (quote) {
+      if (c === quote) quote = null;
+      cur += c;
+      continue;
+    }
+    if (c === '"' || c === "'") { quote = c; cur += c; continue; }
+    let matched = null;
+    for (const sep of seps) if (line.startsWith(sep, i)) { matched = sep; break; }
+    if (matched) {
+      cmds.push(cur.trim());
+      separators.push(matched);
+      cur = '';
+      i += matched.length - 1;
+      continue;
+    }
+    cur += c;
+  }
+  if (cur.trim()) cmds.push(cur.trim());
+  return cmds.map((cmd, i) => ({ cmd, sep: separators[i - 1] || null }));
+}
+
+export function parseRedirects(tokens) {
+  const out = { args: [], stdout: null, stdoutAppend: false, stdin: null };
+  for (let i = 0; i < tokens.length; i++) {
+    const t = tokens[i];
+    if (t === '>' || t === '>>') { out.stdout = tokens[++i]; out.stdoutAppend = t === '>>'; continue; }
+    if (t === '<') { out.stdin = tokens[++i]; continue; }
+    out.args.push(t);
+  }
+  return out;
+}
+
+export function parsePipes(line) {
+  return splitTopLevel(line, ['|']).map(p => p.cmd);
+}
+
+export function globToRe(pattern) {
+  let re = '';
+  let i = 0;
+  while (i < pattern.length) {
+    const c = pattern[i];
+    if (c === '[') {
+      const close = pattern.indexOf(']', i + 1);
+      if (close < 0) { re += '\\['; i++; continue; }
+      let cls = pattern.slice(i + 1, close);
+      if (cls[0] === '!') cls = '^' + cls.slice(1);
+      re += '[' + cls + ']';
+      i = close + 1; continue;
+    }
+    if (c === '*') { re += pattern[i + 1] === '*' ? ((i += 2), '.*') : ((i++), '[^/]*'); continue; }
+    if (c === '?') { re += '[^/]'; i++; continue; }
+    if ('-{}()+.,\\^$|#'.includes(c)) { re += '\\' + c; i++; continue; }
+    re += c; i++;
+  }
+  return new RegExp('^' + re + '$');
+}
+
+export function parseCommand(line, env) {
+  const raw = tokenize(line);
+  const expanded = raw.map(t => expand(t, env));
+  return parseRedirects(expanded);
+}

package/docs/shell-pm-layout.js

@@ -0,0 +1,62 @@
+import { detectPm } from './shell-pm.js';
+
+const hashOf=(name,ver)=>{let h=0;for(const c of name+'@'+ver)h=((h<<5)-h+c.charCodeAt(0))|0;return(h>>>0).toString(36);};
+
+export function makePnpmLayout(fs,snap,persist,ctx){
+  const storeBase=()=>{const d=ctx.cwd.replace(/^\//,'').replace(/\/$/,'');return(d?d+'/':'')+'node_modules/.pnpm';};
+  return{
+    install(name,ver){
+      if(!fs.symlinkSync)throw new Error('pnpm layout requires symlink support');
+      const base=ctx.cwd.replace(/^\//,'').replace(/\/$/,'');
+      const store=storeBase()+'/'+name+'@'+ver+'/node_modules/'+name;
+      const linkPath='/'+(base?base+'/':'')+'node_modules/'+name;
+      const storePath='/'+store;
+      if(!fs.existsSync('/'+store+'/package.json')){
+        fs.mkdirSync('/'+store,{recursive:true});
+        snap()['/'+store+'/package.json'.replace(/^\//,'')]=JSON.stringify({name,version:ver,main:'index.js'});
+        snap()['/'+store+'/index.js'.replace(/^\//,'')]=`import('https://esm.sh/${name}@${ver}').then(m=>module.exports=m.default||m);`;
+      }
+      if(!fs.existsSync(linkPath))fs.symlinkSync(storePath,linkPath);
+      persist();
+    },
+    resolve(name){const base=ctx.cwd.replace(/^\//,'').replace(/\/$/,'');return'/'+(base?base+'/':'')+'node_modules/'+name;}
+  };
+}
+
+export function parseWorkspaces(snap,cwd=''){
+  const base=cwd.replace(/^\//,'').replace(/\/$/,'');
+  const pj=snap[(base?base+'/':'')+'package.json'];
+  const wsYaml=snap[(base?base+'/':'')+'pnpm-workspace.yaml'];
+  let patterns=[];
+  if(pj){try{const p=JSON.parse(pj);if(Array.isArray(p.workspaces))patterns=p.workspaces;else if(p.workspaces?.packages)patterns=p.workspaces.packages;}catch{}}
+  if(wsYaml){const m=wsYaml.match(/packages:\s*([\s\S]+?)(?=\n\w|$)/);if(m){for(const line of m[1].split('\n')){const x=line.match(/^\s*-\s*['"]?([^'"\n]+)['"]?/);if(x)patterns.push(x[1]);}}}
+  const members=[];
+  for(const pat of patterns){
+    const re=new RegExp('^'+(base?base+'/':'')+pat.replace(/\*\*/g,'.+').replace(/\*/g,'[^/]+')+'/package.json$');
+    for(const k of Object.keys(snap))if(re.test(k)){const p=JSON.parse(snap[k]);members.push({path:k.replace(/\/package\.json$/,''),name:p.name,version:p.version,deps:p.dependencies||{}});}
+  }
+  return members;
+}
+
+export function parseYarnLockV1(src){
+  const entries={};
+  const blocks=src.split(/\n\n/).filter(b=>b.trim()&&!b.startsWith('#'));
+  for(const block of blocks){
+    const lines=block.split('\n');const header=lines[0].replace(/:$/,'').replace(/"/g,'');
+    const meta={};for(const line of lines.slice(1)){const m=line.match(/^\s+(\w+)\s+"?([^"]+)"?/);if(m)meta[m[1]]=m[2];}
+    for(const key of header.split(',').map(s=>s.trim()))entries[key]={version:meta.version,resolved:meta.resolved,integrity:meta.integrity};
+  }
+  return entries;
+}
+
+export function writeYarnLockV1(deps){
+  const lines=['# THIS IS AN AUTOGENERATED FILE.',''];
+  for(const[name,ver] of Object.entries(deps)){
+    lines.push(`"${name}@${ver}":`,`  version "${ver.replace(/^[\^~]/,'')}"`,`  resolved "https://registry.npmjs.org/${name}/-/${name}-${ver.replace(/^[\^~]/,'')}.tgz"`,'');
+  }
+  return lines.join('\n');
+}
+
+export function makeDlx(term,fs,ctx,runCmd){
+  return async args=>{const pkg=args[0];if(!pkg)return 1;const spec=pkg.match(/^(@?[^@]+)(?:@(.+))?$/);const name=spec[1];term.write(`dlx: loading ${pkg} from esm.sh\r\n`);try{const mod=await import('https://esm.sh/'+pkg);const main=mod.default||mod;if(typeof main==='function')return main(args.slice(1))||0;return 0;}catch(e){term.write(`dlx: ${e.message}\r\n`);return 1;}};
+}

package/docs/shell-pm.js

@@ -0,0 +1,39 @@
+const LOCKFILES={bun:['bun.lock','bun.lockb'],pnpm:['pnpm-lock.yaml'],yarn:['yarn.lock'],npm:['package-lock.json']};
+
+function stripJsonc(s){return s.replace(/\/\*[\s\S]*?\*\//g,'').replace(/(^|[^:])\/\/.*$/gm,'$1');}
+
+export function detectPm(snap,cwd=''){
+  const base=cwd.replace(/^\//,'').replace(/\/$/,'');
+  const pj=snap[(base?base+'/':'')+'package.json'];
+  if(pj){try{const p=JSON.parse(pj);if(p.packageManager){const m=p.packageManager.match(/^(\w+)@([\d.]+)/);if(m)return{pm:m[1],version:m[2],source:'packageManager'};}}catch{}}
+  for(const[pm,files] of Object.entries(LOCKFILES))for(const f of files)if(((base?base+'/':'')+f) in snap)return{pm,version:'latest',source:'lockfile:'+f};
+  return{pm:'npm',version:'latest',source:'default'};
+}
+
+export function parseBunfig(src){const o={};for(const line of src.split('\n')){const m=line.match(/^\s*(\w+)\s*=\s*(.+)$/);if(m)o[m[1]]=m[2].trim().replace(/^["']|["']$/g,'');}return o;}
+
+export function parseDenoJson(src){try{return JSON.parse(stripJsonc(src));}catch{return{};}}
+
+export function makePmDispatcher(term,fs,persist,ctx){
+  const snap=()=>globalThis.window?.__debug?.idbSnapshot||{};
+  const log=(pm,cmd,args)=>{const reg=globalThis.window?.__debug?.node;if(!reg)return;reg.pm=reg.pm||{history:[]};reg.pm.history.push({ts:Date.now(),pm,cmd,args,cwd:ctx.cwd});if(reg.pm.history.length>200)reg.pm.history.shift();reg.pm.lastPm=pm;};
+  const pkgPath=()=>{const d=ctx.cwd.replace(/^\//,'').replace(/\/$/,'');return(d?d+'/':'')+'package.json';};
+  const readPj=()=>{const p=snap()[pkgPath()];return p?JSON.parse(p):{name:'pkg',version:'0.0.0',dependencies:{}};};
+  const writePj=o=>{snap()[pkgPath()]=JSON.stringify(o,null,2);persist();};
+  const writeLock=(pm,deps)=>{const base=ctx.cwd.replace(/^\//,'').replace(/\/$/,'');const key=(base?base+'/':'')+(LOCKFILES[pm]?.[0]||'package-lock.json');snap()[key]=JSON.stringify({name:pm,version:1,dependencies:deps},null,2);persist();};
+  const cmds={
+    async add(pm,args){const pj=readPj();pj.dependencies=pj.dependencies||{};const dev=args.includes('-D')||args.includes('--save-dev')||args.includes('--dev');const pkgs=args.filter(a=>!a.startsWith('-'));for(const spec of pkgs){const m=spec.match(/^(@?[^@]+)(?:@(.+))?$/);const name=m?.[1]||spec;const ver=m?.[2]||'latest';if(dev){pj.devDependencies=pj.devDependencies||{};pj.devDependencies[name]=ver;}else pj.dependencies[name]=ver;term.write(`${pm} added ${name}@${ver}\r\n`);}writePj(pj);writeLock(pm,pj.dependencies);return 0;},
+    async remove(pm,args){const pj=readPj();const pkgs=args.filter(a=>!a.startsWith('-'));for(const name of pkgs){delete pj.dependencies?.[name];delete pj.devDependencies?.[name];term.write(`${pm} removed ${name}\r\n`);}writePj(pj);writeLock(pm,pj.dependencies||{});return 0;},
+    async install(pm,args){const pj=readPj();const deps={...(pj.dependencies||{}),...(pj.devDependencies||{})};term.write(`${pm} install — ${Object.keys(deps).length} packages resolved via esm.sh\r\n`);writeLock(pm,pj.dependencies||{});return 0;},
+    async run(pm,args){const script=args[0];const pj=readPj();const s=pj.scripts?.[script];if(!s){term.write(`${pm} run: no script '${script}'\r\n`);return 1;}return ctx.exec?.(s)||0;},
+    async task(pm,args){const script=args[0];const base=ctx.cwd.replace(/^\//,'').replace(/\/$/,'');const dj=snap()[(base?base+'/':'')+'deno.json']||snap()[(base?base+'/':'')+'deno.jsonc'];if(!dj)return 1;const cfg=parseDenoJson(dj);const s=cfg.tasks?.[script];if(!s){term.write(`deno task: no task '${script}'\r\n`);return 1;}return ctx.exec?.(s)||0;},
+    async ls(pm,args){const pj=readPj();const deps={...(pj.dependencies||{}),...(pj.devDependencies||{})};for(const[n,v] of Object.entries(deps))term.write(`  ${n}@${v}\r\n`);return 0;},
+    async init(pm,args){writePj({name:'pkg',version:'0.1.0',type:'module',scripts:{test:'echo test'}});term.write(`${pm} init — package.json created\r\n`);return 0;},
+  };
+  cmds.i=cmds.install;cmds.uninstall=cmds.remove;cmds.rm=cmds.remove;
+  return async(pm,subcmd,args=[])=>{log(pm,subcmd,args);const fn=cmds[subcmd];if(!fn){term.write(`${pm}: unknown subcommand '${subcmd}'\r\n`);return 1;}return fn(pm,args);};
+}
+
+export function makeCorepackStub(term){
+  return async(args)=>{term.write(`corepack: ${args.join(' ')} — no-op in browser (all PMs built-in)\r\n`);return 0;};
+}

package/docs/shell-posix.js

@@ -0,0 +1,70 @@
+const SYMLOOP_MAX=40;
+const S_IFREG=0o100000,S_IFDIR=0o040000,S_IFLNK=0o120000,S_IFIFO=0o010000,S_IFMT=0o170000;
+const isMeta=v=>v!==null&&typeof v==='object'&&!ArrayBuffer.isView(v)&&(v.__symlink||v.__fifo||('data' in v&&'mode' in v));
+const unwrapData=v=>isMeta(v)?v.data:v;
+const toKey=p=>p.replace(/^\//,'');
+let nextIno=1;const inodes=new Map();
+
+export function installPosixFs(fs,Buf,ctx){
+  const snap=()=>globalThis.window?.__debug?.idbSnapshot||{};
+  const persist=()=>globalThis.window?.__debug?.idbPersist?.();
+  const newIno=()=>++nextIno;
+  const ensureInode=(key,s)=>{let e=s[key];if(!isMeta(e)){s[key]={data:e==null?'':e,mode:0o100644,ino:newIno(),nlink:1,uid:0,gid:0,atime:Date.now(),mtime:Date.now(),ctime:Date.now(),birthtime:Date.now()};e=s[key];}return e;};
+
+  const resolveLink=(p,depth=0)=>{
+    if(depth>SYMLOOP_MAX){const e=new Error('ELOOP: '+p);e.code='ELOOP';throw e;}
+    const key=toKey(p);const entry=snap()[key];
+    if(isMeta(entry)&&entry.__symlink){const tgt=entry.__symlink.startsWith('/')?entry.__symlink:p.replace(/[^/]+$/,'')+entry.__symlink;return resolveLink(tgt,depth+1);}
+    return p;
+  };
+
+  const origRead=fs.readFileSync,origWrite=fs.writeFileSync,origStat=fs.statSync,origExists=fs.existsSync,origRm=fs.unlinkSync;
+  fs.readFileSync=(p,enc)=>{const real=resolveLink(p);const entry=snap()[toKey(real)];if(entry==null){const e=new Error('ENOENT: '+p);e.code='ENOENT';throw e;}const data=unwrapData(entry);return enc?(typeof data==='string'?data:new TextDecoder(enc==='utf-8'?'utf-8':enc).decode(data)):(typeof data==='string'?data:Buf.from(data));};
+  fs.writeFileSync=(p,data,opts)=>{const real=resolveLink(p);const s=snap();const key=toKey(real);const mode=S_IFREG|((typeof opts?.mode==='number'?opts.mode:0o666)&~(ctx.umask||0o022));const existing=s[key];if(isMeta(existing)&&!existing.__symlink){existing.data=data;existing.mtime=Date.now();existing.ctime=Date.now();}else if(isMeta(existing)){existing.data=data;}else{s[key]={data,mode,ino:newIno(),nlink:1,uid:0,gid:0,atime:Date.now(),mtime:Date.now(),ctime:Date.now(),birthtime:Date.now()};}persist();};
+  fs.existsSync=p=>{try{const real=resolveLink(p);const key=toKey(real);const s=snap();return key in s||Object.keys(s).some(k=>k.startsWith(key+'/'));}catch{return false;}};
+  fs.statSync=p=>{const real=resolveLink(p);const s=snap();const key=toKey(real);const entry=s[key];const hasDirChildren=Object.keys(s).some(k=>k.startsWith(key+'/'));if(entry==null){if(hasDirChildren)return makeStats({mode:S_IFDIR|0o755,ino:newIno(),size:0});const e=new Error('ENOENT: '+p);e.code='ENOENT';throw e;}if(isMeta(entry)){const m=entry.mode||S_IFREG|0o644;return makeStats({...entry,mode:m,size:typeof entry.data==='string'?entry.data.length:entry.data?.byteLength||0});}return makeStats({mode:S_IFREG|0o644,ino:newIno(),size:typeof entry==='string'?entry.length:entry?.byteLength||0});};
+  fs.lstatSync=p=>{const s=snap();const entry=s[toKey(p)];if(entry==null){if(!origExists(p)){const e=new Error('ENOENT: '+p);e.code='ENOENT';throw e;}return makeStats({mode:S_IFDIR|0o755,ino:newIno(),size:0});}if(isMeta(entry)&&entry.__symlink)return makeStats({mode:S_IFLNK|0o777,ino:newIno(),size:entry.__symlink.length});return fs.statSync(p);};
+  fs.readlinkSync=p=>{const entry=snap()[toKey(p)];if(!isMeta(entry)||!entry.__symlink){const e=new Error('EINVAL: '+p);e.code='EINVAL';throw e;}return entry.__symlink;};
+  fs.symlinkSync=(target,path)=>{snap()[toKey(path)]={__symlink:target,mode:S_IFLNK|0o777,ino:newIno()};persist();};
+  fs.linkSync=(src,dst)=>{const s=snap();const entry=ensureInode(toKey(resolveLink(src)),s);s[toKey(dst)]={...entry,nlink:(entry.nlink||1)+1};entry.nlink=(entry.nlink||1)+1;persist();};
+  fs.unlinkSync=p=>{const key=toKey(p);const s=snap();const entry=s[key];if(entry==null){const e=new Error('ENOENT: '+p);e.code='ENOENT';throw e;}delete s[key];persist();};
+  fs.chmodSync=(p,mode)=>{const real=resolveLink(p);const entry=ensureInode(toKey(real),snap());entry.mode=(entry.mode&S_IFMT)|(mode&0o7777);entry.ctime=Date.now();persist();};
+  fs.realpathSync=p=>resolveLink(p);
+  fs.realpathSync.native=fs.realpathSync;
+  fs.cpSync=(src,dst,opts={})=>{const sKey=toKey(src),dKey=toKey(dst);const s=snap();const entry=s[sKey];if(entry!=null){s[dKey]=isMeta(entry)?{...entry,ino:newIno(),nlink:1}:entry;}if(opts.recursive){for(const k of Object.keys(s))if(k.startsWith(sKey+'/')){const rel=k.slice(sKey.length);const sub=s[k];s[dKey+rel]=isMeta(sub)?{...sub,ino:newIno(),nlink:1}:sub;}}persist();};
+  fs.constants=fs.constants||{};Object.assign(fs.constants,{S_IFREG,S_IFDIR,S_IFLNK,S_IFIFO,S_IFMT,S_IXUSR:0o100,S_IWUSR:0o200,S_IRUSR:0o400,O_RDONLY:0,O_WRONLY:1,O_RDWR:2,O_CREAT:64,O_EXCL:128,O_TRUNC:512,O_APPEND:1024});
+  return fs;
+}
+
+function makeStats(o){
+  const mode=o.mode||0o100644;
+  return{
+    dev:1,ino:o.ino||0,mode,nlink:o.nlink||1,uid:o.uid||0,gid:o.gid||0,rdev:0,size:o.size||0,blksize:4096,blocks:Math.ceil((o.size||0)/512),
+    atimeMs:o.atime||Date.now(),mtimeMs:o.mtime||Date.now(),ctimeMs:o.ctime||Date.now(),birthtimeMs:o.birthtime||Date.now(),
+    atime:new Date(o.atime||Date.now()),mtime:new Date(o.mtime||Date.now()),ctime:new Date(o.ctime||Date.now()),birthtime:new Date(o.birthtime||Date.now()),
+    isFile(){return(mode&S_IFMT)===S_IFREG;},
+    isDirectory(){return(mode&S_IFMT)===S_IFDIR;},
+    isSymbolicLink(){return(mode&S_IFMT)===S_IFLNK;},
+    isFIFO(){return(mode&S_IFMT)===S_IFIFO;},
+    isBlockDevice(){return false;},isCharacterDevice(){return false;},isSocket(){return false;},
+  };
+}
+
+export function installFds(fs,Buf){
+  const fdTable=new Map();let nextFd=3;
+  fs.openSync=(p,flags='r',mode=0o644)=>{const f=nextFd++;const exists=fs.existsSync(p);if(flags.includes('x')&&exists){const e=new Error('EEXIST: '+p);e.code='EEXIST';throw e;}if((flags.includes('w')||flags.includes('a'))&&!exists)fs.writeFileSync(p,'');if(flags.includes('w')&&exists)fs.writeFileSync(p,'');fdTable.set(f,{path:p,flags,position:flags.includes('a')?(fs.statSync(p).size):0,mode});return f;};
+  fs.closeSync=fd=>{fdTable.delete(fd);};
+  fs.readSync=(fd,buf,offset,length,position)=>{const e=fdTable.get(fd);if(!e)throw Object.assign(new Error('EBADF'),{code:'EBADF'});const data=fs.readFileSync(e.path);const bytes=typeof data==='string'?new TextEncoder().encode(data):data;const pos=position==null?e.position:position;const n=Math.min(length,bytes.length-pos);for(let i=0;i<n;i++)buf[offset+i]=bytes[pos+i];if(position==null)e.position+=n;return n;};
+  fs.writeSync=(fd,buf,offset,length,position)=>{const e=fdTable.get(fd);if(!e)throw Object.assign(new Error('EBADF'),{code:'EBADF'});const existing=fs.existsSync(e.path)?fs.readFileSync(e.path):'';const existingBytes=typeof existing==='string'?new TextEncoder().encode(existing):existing;const pos=position==null?e.position:position;const slice=buf.slice(offset||0,(offset||0)+(length||buf.length));const out=new Uint8Array(Math.max(existingBytes.length,pos+slice.length));out.set(existingBytes);out.set(slice,pos);fs.writeFileSync(e.path,Buf.from(out));if(position==null)e.position=pos+slice.length;return slice.length;};
+  fs.fstatSync=fd=>{const e=fdTable.get(fd);return fs.statSync(e.path);};
+  fs.fsyncSync=()=>{};fs.ftruncateSync=(fd,len=0)=>{const e=fdTable.get(fd);const cur=fs.readFileSync(e.path);const bytes=typeof cur==='string'?new TextEncoder().encode(cur):cur;fs.writeFileSync(e.path,Buf.from(bytes.slice(0,len)));};
+  return fs;
+}
+
+export function installTmpAndMisc(fs,Buf,ctx){
+  const snap=()=>globalThis.window?.__debug?.idbSnapshot||{};
+  fs.mkdtempSync=prefix=>{const suffix=Math.random().toString(36).slice(2,8);const p=prefix+suffix;fs.mkdirSync(p);return p;};
+  fs.mkfifoSync=p=>{snap()[p.replace(/^\//,'')]={__fifo:{buf:[],readers:[],writers:[]},mode:0o010644,ino:0};};
+  ctx.umask=ctx.umask||0o022;
+  return fs;
+}

package/docs/shell-procsub.js

@@ -0,0 +1,65 @@
+const streams = new Map();
+let nextStreamId = 1000;
+
+export function registerStream(data) {
+  const id = nextStreamId++;
+  streams.set(id, { data, ts: Date.now() });
+  setTimeout(() => streams.delete(id), 60000);
+  return '/procsub/' + id;
+}
+
+export function readStream(id) {
+  const s = streams.get(+id);
+  return s ? s.data : null;
+}
+
+if (typeof navigator !== 'undefined' && navigator.serviceWorker) {
+  navigator.serviceWorker.addEventListener('message', ev => {
+    if (ev.data?.type === 'PROCSUB_READ') {
+      const data = readStream(ev.data.id);
+      ev.ports[0]?.postMessage({ data: data || '', found: data !== null });
+    }
+  });
+}
+
+export async function expandProcSub(token, captureRun, ctx) {
+  const out = [];
+  let i = 0;
+  while (i < token.length) {
+    if (token[i] === '<' && token[i + 1] === '(') {
+      const end = findMatch(token, i + 1);
+      if (end < 0) { out.push(token[i++]); continue; }
+      const cmd = token.slice(i + 2, end);
+      const data = captureRun ? captureRun(cmd) : '';
+      out.push(registerStream(data));
+      i = end + 1; continue;
+    }
+    if (token[i] === '>' && token[i + 1] === '(') {
+      const end = findMatch(token, i + 1);
+      if (end < 0) { out.push(token[i++]); continue; }
+      const cmd = token.slice(i + 2, end);
+      const path = registerStream('');
+      ctx.pendingWrites = ctx.pendingWrites || [];
+      ctx.pendingWrites.push({ path, cmd });
+      out.push(path);
+      i = end + 1; continue;
+    }
+    out.push(token[i++]);
+  }
+  return out.join('');
+}
+
+function findMatch(s, start) {
+  let depth = 0;
+  for (let i = start; i < s.length; i++) {
+    if (s[i] === '(') depth++;
+    else if (s[i] === ')') { depth--; if (depth === 0) return i; }
+  }
+  return -1;
+}
+
+export function swFetchProcSub(path) {
+  const m = path.match(/^\/procsub\/(\d+)$/);
+  if (!m) return null;
+  return readStream(m[1]);
+}

package/docs/shell-readline.js

@@ -1,9 +1,12 @@
-export function createReadline({ term, getCompletions, onLine, getPrompt }) {
+export function createReadline({ term, getCompletions, onLine, getPrompt, isBlockOpen }) {
   let buf = '';
   let pos = 0;
   let histIdx = -1;
   let escBuf = '';
   let inEsc = false;
+  let heredocTag = null;
+  let heredocBody = '';
+  let heredocPrefix = '';
 
   const write = s => term.write(s);
 
@@ -71,12 +74,52 @@ export function createReadline({ term, getCompletions, onLine, getPrompt }) {
   function commit() {
     const line = buf;
     write('\r\n');
+    if (heredocTag !== null) {
+      if (line === heredocTag) {
+        const full = heredocPrefix + " '" + heredocBody.replace(/'/g, "'\\''") + "'";
+        heredocTag = null; heredocBody = ''; heredocPrefix = '';
+        buf = ''; pos = 0; histIdx = -1;
+        onLine(full);
+        return;
+      }
+      heredocBody += line + '\n';
+      buf = ''; pos = 0;
+      write('\x1b[32m> \x1b[0m');
+      return;
+    }
+    const hd = line.match(/^(.*?)<<-?\s*(['"]?)(\w+)\2\s*$/);
+    if (hd) {
+      heredocPrefix = hd[1].trim();
+      heredocTag = hd[3];
+      heredocBody = '';
+      buf = ''; pos = 0;
+      write('\x1b[32m> \x1b[0m');
+      return;
+    }
+    const hereStr = line.match(/^(.*?)<<<\s*(.+)$/);
+    if (hereStr) {
+      const body = hereStr[2].replace(/^["']|["']$/g, '');
+      const full = hereStr[1].trim() + ' "' + body.replace(/"/g, '\\"') + '"';
+      buf = ''; pos = 0; histIdx = -1;
+      const hist = getHistory();
+      if (line.trim()) hist.unshift(line);
+      onLine(full);
+      return;
+    }
+    if (line.endsWith('\\')) {
+      buf = line.slice(0, -1) + '\n';
+      pos = buf.length;
+      write('\x1b[32m> \x1b[0m');
+      return;
+    }
     const hist = getHistory();
-    if (line.trim()) hist.unshift(line);
+    const expanded = expandBang(line, hist);
+    if (expanded !== line) { write('\x1b[33m' + expanded + '\x1b[0m\r\n'); }
+    if (expanded.trim()) hist.unshift(expanded);
     buf = '';
     pos = 0;
     histIdx = -1;
-    onLine(line);
+    onLine(expanded);
   }
 
   function getHistory() { return window.__debug?.shell?.history || []; }
@@ -126,5 +169,17 @@ export function createReadline({ term, getCompletions, onLine, getPrompt }) {
     if (data >= ' ') { insert(data); return; }
   }
 
-  return { onData, showPrompt };
+  function showContinuation() { write('\x1b[32m> \x1b[0m'); }
+
+  return { onData, showPrompt, showContinuation };
+}
+
+function expandBang(line, hist) {
+  if (!line.includes('!') || !hist.length) return line;
+  return line.replace(/!(!|-?\d+|[A-Za-z]\w*)/g, (m, ref) => {
+    if (ref === '!') return hist[0] || m;
+    if (/^-?\d+$/.test(ref)) { const n = +ref; return (n < 0 ? hist[-n - 1] : hist[hist.length - n]) || m; }
+    const found = hist.find(h => h.startsWith(ref));
+    return found || m;
+  });
 }

package/docs/shell-runtime.js

@@ -0,0 +1,37 @@
+export function detectRuntime(){
+  const g=globalThis;
+  let runtime='browser',version='0';
+  if(g.Deno?.version){runtime='deno';version=g.Deno.version.deno;}
+  else if(g.Bun?.version){runtime='bun';version=g.Bun.version;}
+  else if(g.process?.versions?.bun){runtime='bun';version=g.process.versions.bun;}
+  else if(g.process?.versions?.node){runtime='node';version=g.process.versions.node;}
+  const features={
+    jsr:runtime==='deno'||runtime==='bun'||runtime==='browser',
+    npmSpecifier:runtime==='deno'||runtime==='bun'||runtime==='browser',
+    bunServe:typeof g.Bun?.serve==='function'||runtime==='browser',
+    denoPermissions:runtime==='deno',
+    typeStrip:runtime==='bun'||runtime==='deno'||runtime==='browser',
+    workspaceRoot:true,
+    shebangDispatch:true,
+  };
+  return{runtime,version,features};
+}
+
+export function registerRuntime(reg,rt){
+  reg.runtime={active:rt.runtime,version:rt.version,features:rt.features,available:['node','deno','bun','browser'],history:[]};
+  return reg;
+}
+
+export function logRuntimeSwitch(reg,from,to,reason){
+  if(!reg?.runtime)return;
+  reg.runtime.history.push({ts:Date.now(),from,to,reason});
+  if(reg.runtime.history.length>50)reg.runtime.history.shift();
+  reg.runtime.active=to;
+}
+
+export function switchRuntime(shebang){
+  if(!shebang)return'node';
+  if(shebang.includes('deno'))return'deno';
+  if(shebang.includes('bun'))return'bun';
+  return'node';
+}

package/docs/shell-sed.js

@@ -0,0 +1,83 @@
+export function runSed(exprs, stdin) {
+  const ops = exprs.flatMap(parseSed);
+  const labels = {};
+  ops.forEach((op, i) => { if (op.cmd === ':') labels[op.label] = i; });
+  const lines = stdin.split('\n');
+  const out = [];
+  let pat = null, hold = '';
+  let nr = 0;
+  let i = 0;
+  while (i < lines.length) {
+    pat = lines[i]; nr = i + 1;
+    let pc = 0, deleted = false, lastSubOk = false;
+    while (pc < ops.length) {
+      const op = ops[pc];
+      if (op.cmd === ':') { pc++; continue; }
+      if (op.addr != null && !addrMatch(op.addr, nr, pat, lines.length)) { pc++; continue; }
+      if (op.cmd === 's') { const before = pat; pat = pat.replace(op.re, op.rep); lastSubOk = pat !== before; pc++; continue; }
+      if (op.cmd === 'd') { deleted = true; break; }
+      if (op.cmd === 'p') { out.push(pat); pc++; continue; }
+      if (op.cmd === 'P') { out.push(pat.split('\n')[0]); pc++; continue; }
+      if (op.cmd === 'h') { hold = pat; pc++; continue; }
+      if (op.cmd === 'H') { hold += '\n' + pat; pc++; continue; }
+      if (op.cmd === 'g') { pat = hold; pc++; continue; }
+      if (op.cmd === 'G') { pat += '\n' + hold; pc++; continue; }
+      if (op.cmd === 'x') { const t = pat; pat = hold; hold = t; pc++; continue; }
+      if (op.cmd === 'n') { out.push(pat); i++; if (i >= lines.length) { pat = null; break; } pat = lines[i]; nr = i + 1; pc++; continue; }
+      if (op.cmd === 'N') { i++; if (i >= lines.length) break; pat += '\n' + lines[i]; nr = i + 1; pc++; continue; }
+      if (op.cmd === 'D') { const nl = pat.indexOf('\n'); if (nl < 0) { deleted = true; break; } pat = pat.slice(nl + 1); pc = 0; continue; }
+      if (op.cmd === 'b') { pc = op.label ? (labels[op.label] ?? ops.length) : ops.length; continue; }
+      if (op.cmd === 't') { if (lastSubOk) { lastSubOk = false; pc = op.label ? (labels[op.label] ?? ops.length) : ops.length; continue; } pc++; continue; }
+      if (op.cmd === 'a') { out.push(pat); out.push(op.text); pat = null; break; }
+      if (op.cmd === 'i') { out.push(op.text); pc++; continue; }
+      if (op.cmd === 'c') { pat = op.text; pc++; continue; }
+      if (op.cmd === 'q') { if (!deleted && pat != null) out.push(pat); return out.join('\n'); }
+      pc++;
+    }
+    if (!deleted && pat != null) out.push(pat);
+    i++;
+  }
+  return out.join('\n');
+}
+
+function parseSed(expr) {
+  const out = [];
+  for (const part of splitExprs(expr)) {
+    const t = part.trim();
+    if (!t) continue;
+    const lbl = t.match(/^:(\w+)$/);
+    if (lbl) { out.push({ cmd: ':', label: lbl[1] }); continue; }
+    const addrM = t.match(/^(\d+|\/[^/]+\/|\$)(.+)$/);
+    let addr = null; let rest = t;
+    if (addrM && !t.startsWith('s')) { addr = addrM[1]; rest = addrM[2]; }
+    const sM = rest.match(/^s(.)(.+?)\1(.*?)\1([gip]*)$/);
+    if (sM) { out.push({ cmd: 's', addr, re: new RegExp(sM[2], sM[4].includes('g') ? 'g' : ''), rep: sM[3] }); continue; }
+    const br = rest.match(/^([bt])\s*(\w*)$/);
+    if (br) { out.push({ cmd: br[1], addr, label: br[2] || null }); continue; }
+    const plain = rest.match(/^([dpPhHgGxnNDq])$/);
+    if (plain) { out.push({ cmd: plain[1], addr }); continue; }
+    const textM = rest.match(/^([aic])\\?\s*(.*)$/);
+    if (textM) { out.push({ cmd: textM[1], addr, text: textM[2] }); continue; }
+  }
+  return out;
+}
+
+function splitExprs(s) {
+  const out = []; let cur = ''; let escape = false;
+  for (const c of s) {
+    if (escape) { cur += c; escape = false; continue; }
+    if (c === '\\') { cur += c; escape = true; continue; }
+    if (c === ';') { if (cur) out.push(cur); cur = ''; continue; }
+    cur += c;
+  }
+  if (cur) out.push(cur);
+  return out;
+}
+
+function addrMatch(addr, n, line, totalLines) {
+  if (addr === '$') return n === totalLines;
+  if (/^\d+$/.test(addr)) return +addr === n;
+  const re = addr.match(/^\/(.+)\/$/);
+  if (re) return new RegExp(re[1]).test(line);
+  return false;
+}

package/docs/shell-signals.js

@@ -0,0 +1,54 @@
+export function createSignals(ctx) {
+  const pending = [];
+  const handlers = ctx.traps || (ctx.traps = {});
+  return {
+    raise(sig) { pending.push(sig); },
+    async check(run) {
+      while (pending.length) {
+        const sig = pending.shift();
+        if (sig === 'KILL') { const j = ctx.currentJob; if (j) j.killed = true; throw new Error('killed by SIGKILL'); }
+        const h = handlers[sig];
+        if (h) { try { await run(h); } catch (e) { ctx.term.write('\x1b[31mtrap: ' + e.message + '\x1b[0m\r\n'); } }
+        if (sig === 'INT' && !h && ctx.currentJob) ctx.currentJob.killed = true;
+      }
+    },
+    pending: () => pending.slice(),
+  };
+}
+
+export function makeKillBuiltin(ctx) {
+  return args => {
+    let sig = 'TERM';
+    const targets = [];
+    for (const a of args) {
+      if (a.startsWith('-')) sig = a.slice(1).replace(/^SIG/, '');
+      else targets.push(a);
+    }
+    for (const t of targets) {
+      const id = t.startsWith('%') ? t.slice(1) : t;
+      const job = ctx.bgJobs?.[id];
+      if (!job) { ctx.term.write('kill: ' + t + ': no such job\r\n'); ctx.lastExitCode = 1; continue; }
+      if (job.actor) job.actor.send({ type: 'SIGNAL', sig });
+      if (sig === 'KILL' || sig === '9') { job.killed = true; if (job.reject) job.reject(new Error('killed')); }
+      if (sig === 'STOP' || sig === 'TSTP') { if (job.actor) job.actor.send({ type: 'STOP' }); job.stopped = true; }
+      if (sig === 'CONT') { if (job.actor) job.actor.send({ type: 'CONT' }); job.stopped = false; }
+    }
+  };
+}
+
+export function makeTrapBuiltin(ctx) {
+  return args => {
+    const handlers = ctx.traps || (ctx.traps = {});
+    if (!args.length) {
+      for (const [sig, cmd] of Object.entries(handlers)) ctx.term.write("trap -- '" + cmd + "' " + sig + '\r\n');
+      return;
+    }
+    if (args[0] === '-l') { ctx.term.write('HUP INT QUIT ILL TRAP ABRT BUS FPE KILL USR1 SEGV USR2 PIPE ALRM TERM STOP TSTP CONT CHLD TTIN TTOU URG XCPU XFSZ VTALRM PROF WINCH IO PWR SYS\r\n'); return; }
+    const [cmd, ...sigs] = args;
+    for (const s of sigs) {
+      const norm = s.replace(/^SIG/, '').toUpperCase();
+      if (cmd === '-' || cmd === '') delete handlers[norm];
+      else handlers[norm] = cmd;
+    }
+  };
+}