thebird 1.2.78 → 1.2.80

package/docs/shell-node-extras.js

@@ -0,0 +1,148 @@
+export function extendBuffer(Buf) {
+  const proto = Buf.prototype;
+  proto.readBigUInt64BE = function(o=0){return (BigInt(this.readUInt32BE(o))<<32n)|BigInt(this.readUInt32BE(o+4));};
+  proto.readBigUInt64LE = function(o=0){return (BigInt(this.readUInt32LE(o)))|(BigInt(this.readUInt32LE(o+4))<<32n);};
+  proto.readUInt32LE = function(o=0){return (this[o]|(this[o+1]<<8)|(this[o+2]<<16)|(this[o+3]*0x1000000))>>>0;};
+  proto.readDoubleBE = function(o=0){return new DataView(this.buffer,this.byteOffset+o,8).getFloat64(0,false);};
+  proto.readDoubleLE = function(o=0){return new DataView(this.buffer,this.byteOffset+o,8).getFloat64(0,true);};
+  proto.readFloatBE = function(o=0){return new DataView(this.buffer,this.byteOffset+o,4).getFloat32(0,false);};
+  proto.readFloatLE = function(o=0){return new DataView(this.buffer,this.byteOffset+o,4).getFloat32(0,true);};
+  proto.writeUInt16BE = function(v,o=0){this[o]=(v>>8)&0xff;this[o+1]=v&0xff;return o+2;};
+  proto.writeUInt16LE = function(v,o=0){this[o]=v&0xff;this[o+1]=(v>>8)&0xff;return o+2;};
+  proto.writeUInt32BE = function(v,o=0){this[o]=(v>>>24)&0xff;this[o+1]=(v>>>16)&0xff;this[o+2]=(v>>>8)&0xff;this[o+3]=v&0xff;return o+4;};
+  proto.swap16 = function(){for(let i=0;i<this.length;i+=2){const t=this[i];this[i]=this[i+1];this[i+1]=t;}return this;};
+  proto.swap32 = function(){for(let i=0;i<this.length;i+=4){[this[i],this[i+3]]=[this[i+3],this[i]];[this[i+1],this[i+2]]=[this[i+2],this[i+1]];}return this;};
+  proto.swap64 = function(){for(let i=0;i<this.length;i+=8){for(let j=0;j<4;j++){const t=this[i+j];this[i+j]=this[i+7-j];this[i+7-j]=t;}}return this;};
+  Buf.copyBytesFrom = (view,off=0,len)=>Buf.from(view.buffer,view.byteOffset+off,len??view.byteLength-off);
+  return Buf;
+}
+
+const WIN = /^[A-Za-z]:[\\/]/;
+function win32Mod(){
+  const sep='\\';
+  const norm=p=>{const abs=WIN.test(p);const parts=[];for(const s of p.replace(/\//g,'\\').split('\\')){if(s==='..')parts.pop();else if(s&&s!=='.')parts.push(s);}return (abs?p.slice(0,3):'')+parts.slice(abs?1:0).join('\\');};
+  return {sep,delimiter:';',normalize:norm,join:(...a)=>norm(a.join('\\')),resolve:(...a)=>{let r='';for(const p of a)r=WIN.test(p)?p:r+'\\'+p;return norm(r);},dirname:p=>{const i=p.replace(/\//g,'\\').lastIndexOf('\\');return i<=0?'.':p.slice(0,i);},basename:(p,ext)=>{const b=p.replace(/\//g,'\\').split('\\').pop()||'';return ext&&b.endsWith(ext)?b.slice(0,-ext.length):b;},extname:p=>{const b=p.split(/[\\/]/).pop()||'';const i=b.lastIndexOf('.');return i>0?b.slice(i):'';},isAbsolute:p=>WIN.test(p)||p.startsWith('\\'),relative:(f,t)=>t.replace(f+'\\',''),parse:p=>({root:WIN.test(p)?p.slice(0,3):'',dir:p.slice(0,p.lastIndexOf('\\'))||'',base:p.split('\\').pop()||'',ext:'',name:''})};
+}
+export function extendPath(posix){
+  posix.delimiter=':';
+  posix.posix=posix;
+  posix.win32=win32Mod();
+  return posix;
+}
+
+export function createUrlExt(){
+  const pathToFileURL=p=>{const u=new URL('file://');u.pathname=p.startsWith('/')?p:'/'+p;return u;};
+  const fileURLToPath=u=>{const url=typeof u==='string'?new URL(u):u;if(url.protocol!=='file:')throw new TypeError('only file: supported');return decodeURIComponent(url.pathname);};
+  return {URL,URLSearchParams,parse:s=>{const u=new URL(s);return{protocol:u.protocol,host:u.host,hostname:u.hostname,port:u.port,pathname:u.pathname,search:u.search,query:u.search.slice(1),hash:u.hash,href:u.href};},format:o=>{if(o instanceof URL)return o.href;const u=new URL('http://x');for(const[k,v]of Object.entries(o)){try{u[k]=v;}catch{}}return u.href;},resolve:(f,t)=>new URL(t,f).href,pathToFileURL,fileURLToPath,domainToASCII:s=>s,domainToUnicode:s=>s};
+}
+
+export function makeStringDecoder(){
+  class StringDecoder{
+    constructor(enc='utf8'){this.encoding=enc;this._td=new TextDecoder(enc==='utf8'?'utf-8':enc,{fatal:false});this._buf=null;}
+    write(b){return this._td.decode(b,{stream:true});}
+    end(b){return this._td.decode(b||new Uint8Array(0),{stream:false});}
+  }
+  return {StringDecoder};
+}
+
+export function makeReadline(term,proc){
+  return {
+    createInterface:({input,output,prompt='> ',terminal:useTerm}={})=>{
+      const handlers={line:[],close:[],history:[]};
+      const useXterm=useTerm!==false&&term&&(!input||input===proc?.stdin);
+      let buf='';
+      const rl={
+        on:(ev,fn)=>{(handlers[ev]=handlers[ev]||[]).push(fn);return rl;},
+        once:(ev,fn)=>rl.on(ev,(...a)=>{rl.off(ev,fn);fn(...a);}),
+        off:(ev,fn)=>{handlers[ev]=(handlers[ev]||[]).filter(f=>f!==fn);return rl;},
+        write:s=>(output||term)?.write?.(s),
+        prompt:()=>(output||term)?.write?.(prompt),
+        question:(q,cb)=>{(output||term)?.write?.(q);return new Promise(resolve=>{const handler=l=>{rl.off('line',handler);resolve(l);cb?.(l);};handlers.line.push(handler);});},
+        close:()=>{for(const h of handlers.close)h();},
+        setPrompt:p=>{prompt=p;},
+        pause:()=>rl,resume:()=>rl,
+        [Symbol.asyncIterator](){return{next(){return new Promise(r=>{handlers.line.push(function on(l){handlers.line=handlers.line.filter(f=>f!==on);r({value:l,done:false});});});}};}
+      };
+      if(useXterm){
+        const sink=d=>{if(d==='\r'||d==='\n'){const l=buf;buf='';term.write('\r\n');for(const h of handlers.line)h(l);}else if(d==='\x7f'){if(buf.length){buf=buf.slice(0,-1);term.write('\b \b');}}else if(d>=' '){buf+=d;term.write(d);}};
+        if(proc?.stdin?.on)proc.stdin.on('data',sink);
+      }else if(input?._onLine)input._onLine(l=>{for(const h of handlers.line)h(l);});
+      return rl;
+    },
+    cursorTo:(s,x,y)=>{if(s?.write)s.write(`\x1b[${(y||0)+1};${(x||0)+1}H`);},
+    clearLine:s=>s?.write?.('\x1b[2K'),
+    clearScreenDown:s=>s?.write?.('\x1b[J'),
+    moveCursor:(s,dx,dy)=>{if(s?.write){if(dx>0)s.write(`\x1b[${dx}C`);else if(dx<0)s.write(`\x1b[${-dx}D`);if(dy>0)s.write(`\x1b[${dy}B`);else if(dy<0)s.write(`\x1b[${-dy}A`);}},
+    emitKeypressEvents:(stream,rl)=>{if(!stream?.on)return;stream.on('data',d=>{const name=d==='\r'?'return':d==='\x1b[A'?'up':d==='\x1b[B'?'down':d==='\x7f'?'backspace':d.length===1?d:'';stream.emit?.('keypress',d,{name,ctrl:false,meta:false,shift:false,sequence:d});});},
+  };
+}
+
+export function makeTimersMod(){
+  return {setTimeout,setInterval,setImmediate:fn=>setTimeout(fn,0),clearTimeout,clearInterval,clearImmediate:clearTimeout,promises:{setTimeout:ms=>new Promise(r=>setTimeout(r,ms)),setImmediate:()=>Promise.resolve(),setInterval:async function*(ms){while(1){await new Promise(r=>setTimeout(r,ms));yield;}}}};
+}
+
+export function makePerfHooks(){
+  return {performance:globalThis.performance,PerformanceObserver:class{observe(){}disconnect(){}},monitorEventLoopDelay:()=>({enable(){},disable(){},reset(){},min:0,max:0,mean:0,stddev:0,percentile:()=>0}),constants:{NODE_PERFORMANCE_GC_MAJOR:2}};
+}
+
+export function makeV8Mod(){
+  return {getHeapStatistics:()=>({total_heap_size:20000000,used_heap_size:10000000,heap_size_limit:2000000000,total_available_size:1990000000}),getHeapSpaceStatistics:()=>[],serialize:o=>new TextEncoder().encode(JSON.stringify(o)),deserialize:b=>JSON.parse(new TextDecoder().decode(b)),cachedDataVersionTag:()=>0,setFlagsFromString:()=>{}};
+}
+
+export function makeAsyncHooks(){
+  return {createHook:()=>({enable(){return this;},disable(){return this;}}),executionAsyncId:()=>1,triggerAsyncId:()=>0,executionAsyncResource:()=>({}),AsyncLocalStorage:class{constructor(){this._s=null;}run(s,fn,...a){const p=this._s;this._s=s;try{return fn(...a);}finally{this._s=p;}}getStore(){return this._s;}enterWith(s){this._s=s;}disable(){this._s=null;}exit(fn,...a){const p=this._s;this._s=null;try{return fn(...a);}finally{this._s=p;}}},AsyncResource:class{constructor(){}runInAsyncScope(fn,t,...a){return fn.apply(t,a);}}};
+}
+
+export function makeStubs(ctx){
+  const stub=name=>({__stub:name,toString:()=>`[${name} stub]`});
+  return {
+    inspector:{open:()=>{},close:()=>{},url:()=>undefined,waitForDebugger:()=>{},Session:class{connect(){}post(){}}},
+    cluster:{isPrimary:true,isMaster:true,isWorker:false,workers:{},fork:()=>{throw new Error('cluster.fork: not supported in browser')},on:()=>{},emit:()=>{}},
+    sea:{isSea:()=>false,getAsset:()=>{throw new Error('sea.getAsset: no SEA blob')},getRawAsset:()=>{throw new Error('sea.getRawAsset: no SEA blob')}},
+    test_runner:{test:(n,fn)=>Promise.resolve(fn?.()),describe:(n,fn)=>fn?.(),it:(n,fn)=>Promise.resolve(fn?.()),before:fn=>fn?.(),after:fn=>fn?.(),beforeEach:()=>{},afterEach:()=>{},run:()=>({})},
+    readline_promises:{createInterface:()=>({close(){},question:q=>Promise.resolve('')})},
+    punycode:{encode:s=>s,decode:s=>s,toASCII:s=>s,toUnicode:s=>s,ucs2:{encode:a=>String.fromCodePoint(...a),decode:s=>[...s].map(c=>c.codePointAt(0))}},
+    tty:{isatty:()=>true,ReadStream:class{isTTY=true;},WriteStream:class{isTTY=true;columns=80;rows=24;}},
+    domain:{create:()=>({run:fn=>fn(),add(){},remove(){},dispose(){},on(){},emit(){}})},
+    diagnostics_channel:{channel:name=>({hasSubscribers:false,publish(){},subscribe(){},unsubscribe(){}}),hasSubscribers:()=>false},
+    string_decoder:makeStringDecoder(),
+    tls:{connect:()=>{throw new Error('tls.connect: use fetch() for HTTPS in browser');},createServer:()=>{throw new Error('tls.createServer: not supported in browser');},DEFAULT_CIPHERS:'',DEFAULT_MIN_VERSION:'TLSv1.2',DEFAULT_MAX_VERSION:'TLSv1.3'},
+  };
+}
+
+export function makeErrorCodes(){
+  const codes={ERR_MODULE_NOT_FOUND:'Cannot find module',ERR_INVALID_ARG_TYPE:'Invalid argument type',ERR_INVALID_ARG_VALUE:'Invalid argument value',ERR_OUT_OF_RANGE:'Value out of range',ERR_UNHANDLED_ERROR:'Unhandled error',ERR_ASSERTION:'Assertion failed',ERR_UNSUPPORTED_DIR_IMPORT:'Directory import not supported',ERR_PACKAGE_PATH_NOT_EXPORTED:'Package path not exported',ERR_REQUIRE_ESM:'Cannot require() ESM module',ERR_UNKNOWN_FILE_EXTENSION:'Unknown file extension',ERR_UNKNOWN_BUILTIN_MODULE:'Unknown builtin module',ERR_INVALID_URL:'Invalid URL',ERR_STREAM_DESTROYED:'Stream destroyed',ERR_STREAM_WRITE_AFTER_END:'Write after end',ERR_STREAM_PREMATURE_CLOSE:'Premature close'};
+  const make=(code,msg)=>{const e=new Error(msg||codes[code]);e.code=code;return e;};
+  return {codes,make};
+}
+
+export function extendProcessExtras(proc,ctx){
+  proc.stdout.columns=80;proc.stdout.rows=24;proc.stdout.isTTY=true;proc.stdout.getColorDepth=()=>8;proc.stdout.hasColors=()=>true;
+  proc.stderr.columns=80;proc.stderr.rows=24;proc.stderr.isTTY=true;
+  proc.stdin.isTTY=true;
+  proc.resourceUsage=()=>({userCPUTime:0,systemCPUTime:0,maxRSS:50000,sharedMemorySize:0,unsharedDataSize:0,unsharedStackSize:0,minorPageFault:0,majorPageFault:0,swappedOut:0,fsRead:0,fsWrite:0,ipcSent:0,ipcReceived:0,signalsCount:0,voluntaryContextSwitches:0,involuntaryContextSwitches:0});
+  proc.binding=name=>{throw new Error(`process.binding('${name}'): internal bindings not available`);};
+  proc.allowedNodeEnvironmentFlags=new Set(['--experimental-vm-modules','--no-warnings','--loader','--import','--require','-r','--enable-source-maps','--inspect','--inspect-brk','--trace-warnings','--unhandled-rejections','--preserve-symlinks','--no-deprecation','--throw-deprecation']);
+  const nodeOpts=(ctx.env.NODE_OPTIONS||'').split(/\s+/).filter(Boolean);
+  proc.execArgv=nodeOpts;
+  proc.sourceMapsEnabled=nodeOpts.includes('--enable-source-maps');
+  proc.features={inspector:false,debug:false,uv:false,ipv6:true,tls_alpn:false,tls_sni:false,tls_ocsp:false,tls:false,cached_builtins:true};
+  proc.report={getReport:()=>({}),writeReport:()=>'report.json'};
+  proc.availableMemory=()=>1073741824;
+  proc.constrainedMemory=()=>0;
+  proc.loadEnvFile=p=>{};
+  proc.noDeprecation=false;proc.throwDeprecation=false;proc.traceDeprecation=false;
+  proc.sourceMapsEnabled=false;
+  proc.channel=undefined;proc.connected=false;
+  const sigH={};
+  const origOn=proc.on?.bind(proc);
+  proc.on=(ev,fn)=>{if(['SIGINT','SIGTERM','SIGHUP','exit','beforeExit','uncaughtException','unhandledRejection','warning','message'].includes(ev)){(sigH[ev]=sigH[ev]||[]).push(fn);}origOn?.(ev,fn);return proc;};
+  proc._emitSignal=(ev,...a)=>{for(const h of sigH[ev]||[])h(...a);};
+  proc.kill=()=>true;
+  return proc;
+}
+
+export function makeStreamConsumers(){
+  const toArr=async it=>{const a=[];for await(const c of it)a.push(c);return a;};
+  return {text:async s=>{const a=await toArr(s);return a.map(c=>typeof c==='string'?c:new TextDecoder().decode(c)).join('');},json:async s=>JSON.parse(await (await import('./shell-node-extras.js')).makeStreamConsumers().text(s)),arrayBuffer:async s=>{const a=await toArr(s);const b=Buffer.concat(a.map(c=>c instanceof Uint8Array?c:new TextEncoder().encode(c)));return b.buffer;},buffer:async s=>{const a=await toArr(s);return Buffer.concat(a.map(c=>c instanceof Uint8Array?c:new TextEncoder().encode(c)));}};
+}

package/docs/shell-node-firefox.js

@@ -0,0 +1,95 @@
+export function detectBrowser(){
+  const ua=(typeof navigator!=='undefined'?navigator.userAgent:'')||'';
+  const vendor=/Firefox\//.test(ua)?'firefox':/Edg\//.test(ua)?'edge':/Chrome\//.test(ua)?'chromium':/Safari\//.test(ua)?'webkit':'unknown';
+  const m=ua.match(/(Firefox|Chrome|Edg|Safari|Version)\/([\d.]+)/);
+  const version=m?m[2]:'0';
+  const g=globalThis;
+  const caps={
+    opfs:!!(g.navigator?.storage?.getDirectory),
+    sharedArrayBuffer:typeof SharedArrayBuffer!=='undefined'&&g.crossOriginIsolated===true,
+    performanceMemory:!!(g.performance?.memory),
+    compressionStream:typeof g.CompressionStream!=='undefined',
+    webTransport:typeof g.WebTransport!=='undefined',
+    webRTCDataChannel:typeof g.RTCPeerConnection!=='undefined',
+    webCodecs:typeof g.VideoEncoder!=='undefined',
+    storageBuckets:!!(g.navigator?.storageBuckets),
+    fileSystemObserver:typeof g.FileSystemObserver!=='undefined',
+    measureMemory:typeof g.performance?.measureUserAgentSpecificMemory==='function',
+    broadcastChannel:typeof g.BroadcastChannel!=='undefined',
+  };
+  return{vendor,version,ua,capabilities:caps};
+}
+
+export function registerPolyfill(reg,name,backing,reason){
+  reg.polyfills=reg.polyfills||{};
+  reg.polyfills[name]={active:true,backing,reason,activatedAt:Date.now()};
+}
+
+export function makeCompressionStreamZlib(streamMod,Buf){
+  if(typeof CompressionStream==='undefined')return null;
+  const mk=(name,Ctor)=>()=>{const t=new Ctor(name);const reader=t.readable.getReader();const writer=t.writable.getWriter();const out=new streamMod.Transform({transform(c,e,cb){writer.write(c instanceof Uint8Array?c:new TextEncoder().encode(String(c))).then(()=>cb(),cb);},flush(cb){writer.close().then(async()=>{for(;;){const{value,done}=await reader.read();if(done)break;out.push(Buf.from(value));}cb();},cb);}});return out;};
+  return{
+    createGzip:mk('gzip',CompressionStream),
+    createGunzip:mk('gzip',DecompressionStream),
+    createDeflate:mk('deflate',CompressionStream),
+    createInflate:mk('deflate',DecompressionStream),
+    createDeflateRaw:mk('deflate-raw',CompressionStream),
+    createInflateRaw:mk('deflate-raw',DecompressionStream),
+  };
+}
+
+export function makeWebCodecs(){
+  const g=globalThis;
+  if(typeof g.VideoEncoder==='undefined')return null;
+  return{VideoEncoder:g.VideoEncoder,VideoDecoder:g.VideoDecoder,AudioEncoder:g.AudioEncoder,AudioDecoder:g.AudioDecoder,ImageDecoder:g.ImageDecoder,EncodedVideoChunk:g.EncodedVideoChunk,EncodedAudioChunk:g.EncodedAudioChunk,VideoFrame:g.VideoFrame,AudioData:g.AudioData};
+}
+
+export function makeWebPush(){
+  return{
+    async subscribe(applicationServerKey,opts={}){
+      if(!navigator.serviceWorker)throw new Error('web-push: serviceWorker not available');
+      const reg=await navigator.serviceWorker.ready;
+      return reg.pushManager.subscribe({userVisibleOnly:opts.userVisibleOnly!==false,applicationServerKey});
+    },
+    async getSubscription(){
+      const reg=await navigator.serviceWorker?.ready;
+      return reg?reg.pushManager.getSubscription():null;
+    },
+    async unsubscribe(){
+      const sub=await this.getSubscription();
+      return sub?sub.unsubscribe():false;
+    }
+  };
+}
+
+export function makeStorageHelpers(){
+  const g=globalThis;
+  return{
+    async estimate(){if(!g.navigator?.storage?.estimate)return{usage:0,quota:0,usageDetails:{}};return g.navigator.storage.estimate();},
+    async persist(){if(!g.navigator?.storage?.persist)return false;return g.navigator.storage.persist();},
+    async persisted(){if(!g.navigator?.storage?.persisted)return false;return g.navigator.storage.persisted();},
+    buckets:g.navigator?.storageBuckets||null,
+  };
+}
+
+export function makeFsObserver(getSnap,fsWatchers){
+  const g=globalThis;
+  if(typeof g.FileSystemObserver==='undefined')return null;
+  return async (opfsRoot)=>{
+    const obs=new g.FileSystemObserver(records=>{
+      for(const r of records){
+        const path=r.relativePathComponents.join('/');
+        for(const w of fsWatchers)if(path===w.path||(w.recursive&&path.startsWith(w.path+'/')))for(const h of w.handlers.change)h(r.type,path.split('/').pop());
+      }
+    });
+    if(opfsRoot)await obs.observe(opfsRoot,{recursive:true});
+    return obs;
+  };
+}
+
+export function wrapWorkerForFirefox(opts={}){
+  const ua=typeof navigator!=='undefined'?navigator.userAgent:'';
+  const isOldFirefox=/Firefox\/(\d+)/.test(ua)&&parseInt(ua.match(/Firefox\/(\d+)/)[1])<128;
+  if(!isOldFirefox||opts.type!=='module')return opts;
+  return{...opts,type:'classic'};
+}

package/docs/shell-node-git.js

@@ -0,0 +1,60 @@
+let gitMod=null;let gitPromise=null;
+
+async function loadGit(){
+  if(!gitPromise)gitPromise=Promise.all([
+    import('https://esm.sh/isomorphic-git@1.27.1/es2022/isomorphic-git.mjs').then(m=>m.default||m),
+    import('https://esm.sh/isomorphic-git@1.27.1/http/web').then(m=>m.default||m).catch(()=>null),
+  ]).then(([git,http])=>({git,http}));
+  return gitPromise;
+}
+
+export async function preloadGit(){gitMod=await loadGit();return gitMod;}
+
+export function makeGit(fs){
+  const fsAdapter={
+    promises:{
+      async readFile(path,opts){try{const enc=typeof opts==='string'?opts:opts?.encoding;const d=fs.readFileSync(path);if(enc==='utf8'||enc==='utf-8')return typeof d==='string'?d:new TextDecoder().decode(d);return typeof d==='string'?new TextEncoder().encode(d):d;}catch(e){e.code='ENOENT';throw e;}},
+      async writeFile(path,data){const parts=path.split('/');for(let i=1;i<parts.length;i++){const d=parts.slice(0,i).join('/');if(d&&!fs.existsSync(d))fs.mkdirSync(d,{recursive:true});}fs.writeFileSync(path,data);},
+      async unlink(path){fs.unlinkSync(path);},
+      async readdir(path){return fs.readdirSync(path);},
+      async mkdir(path){fs.mkdirSync(path,{recursive:true});},
+      async rmdir(path){fs.rmSync?.(path,{recursive:true})||fs.unlinkSync(path);},
+      async stat(path){return fs.statSync(path);},
+      async lstat(path){return fs.lstatSync?.(path)||fs.statSync(path);},
+      async readlink(path){return fs.readlinkSync?.(path);},
+      async symlink(target,path){fs.symlinkSync?.(target,path);},
+      async chmod(){},
+    },
+  };
+  const need=()=>{if(!gitMod)throw new Error('git: call await preloadGit() once before git ops');return gitMod;};
+  const wrap=method=>async opts=>{const{git,http}=need();return git[method]({fs:fsAdapter,http,...opts});};
+  return{
+    clone:wrap('clone'),
+    init:wrap('init'),
+    add:wrap('add'),
+    commit:wrap('commit'),
+    push:wrap('push'),
+    pull:wrap('pull'),
+    fetch:wrap('fetch'),
+    status:wrap('status'),
+    statusMatrix:wrap('statusMatrix'),
+    log:wrap('log'),
+    listBranches:wrap('listBranches'),
+    branch:wrap('branch'),
+    checkout:wrap('checkout'),
+    resolveRef:wrap('resolveRef'),
+    currentBranch:wrap('currentBranch'),
+    remove:wrap('remove'),
+    listRemotes:wrap('listRemotes'),
+    addRemote:wrap('addRemote'),
+    deleteRemote:wrap('deleteRemote'),
+    merge:wrap('merge'),
+    readBlob:wrap('readBlob'),
+    readTree:wrap('readTree'),
+    readCommit:wrap('readCommit'),
+    tag:wrap('tag'),
+    listTags:wrap('listTags'),
+    diff:async opts=>{const s=await wrap('statusMatrix')(opts);return s.filter(([,,w,s])=>w!==s).map(([path])=>path);},
+    preload:preloadGit,
+  };
+}

package/docs/shell-node-inspector.js

@@ -0,0 +1,39 @@
+export function makeInspector(debugReg){
+  let opened=false;let url=null;let port=null;const sessions=new Set();
+  const targets=()=>[{description:'thebird browser runtime',devtoolsFrontendUrl:'',id:'thebird-1',title:'thebird',type:'node',url:'file://thebird',webSocketDebuggerUrl:url}];
+  const handlers={};
+  const post=(sess,msg)=>{try{sess.send(JSON.stringify(msg));}catch{}};
+  const installServer=u=>{
+    if(typeof globalThis.addEventListener!=='function')return;
+    globalThis.addEventListener('message',e=>{if(e.data?.type!=='cdp:connect')return;const chan=e.data.channel;const sess={send:m=>globalThis.postMessage({type:'cdp:msg',channel:chan,msg:m},'*')};sessions.add(sess);});
+  };
+  const dispatch=(sess,raw)=>{
+    let msg;try{msg=JSON.parse(raw);}catch{return;}
+    const {id,method,params}=msg;
+    const send=result=>post(sess,{id,result});
+    const err=code=>post(sess,{id,error:{code,message:'not implemented'}});
+    const map={
+      'Runtime.enable':()=>send({}),
+      'Runtime.evaluate':()=>{try{const r=(0,eval)(params.expression);send({result:{type:typeof r,value:r,description:String(r)}});}catch(e){send({exceptionDetails:{exception:{type:'object',className:'Error',description:e.stack}}});}},
+      'Debugger.enable':()=>send({debuggerId:'thebird-dbg-1'}),
+      'Debugger.getScriptSource':()=>send({scriptSource:''}),
+      'Profiler.enable':()=>send({}),
+      'Profiler.start':()=>send({}),
+      'Profiler.stop':()=>send({profile:{nodes:[],startTime:0,endTime:0,samples:[],timeDeltas:[]}}),
+      'HeapProfiler.enable':()=>send({}),
+      'HeapProfiler.takeHeapSnapshot':()=>send({}),
+    };
+    const h=map[method];h?h():err(-32601);
+  };
+  return{
+    open(p=9229,host='127.0.0.1',wait=false){if(opened)return;opened=true;port=p;url=`ws://${host}:${p}/${crypto.randomUUID()}`;installServer(url);debugReg.polyfills=debugReg.polyfills||{};debugReg.polyfills.inspector={active:true,backing:'postMessage-CDP',reason:'real WS debugger unavailable in sandbox'};debugReg.inspector={url,port,targets:targets(),sessions};if(wait)throw new Error('inspector.waitForDebugger: sync block not supported — use openAsync()');return{url};},
+    async openAsync(p=9229,host='127.0.0.1'){return this.open(p,host,false);},
+    close(){opened=false;url=null;sessions.clear();},
+    url:()=>url,
+    waitForDebugger(){throw new Error('inspector.waitForDebugger: synchronous block not supported in browser — attach before starting work');},
+    Session:class Session{constructor(){this._h={};}connect(){return this;}post(method,params,cb){queueMicrotask(()=>dispatch({send:m=>{const p=JSON.parse(m);cb&&cb(p.error||null,p.result);}},JSON.stringify({id:1,method,params})));}on(ev,fn){(this._h[ev]=this._h[ev]||[]).push(fn);return this;}disconnect(){return this;}},
+    console:{context:{}},
+    _dispatch:dispatch,
+    _targets:targets,
+  };
+}

package/docs/shell-node-io.js

@@ -0,0 +1,131 @@
+export function createChildProcess(ctx) {
+  async function runThroughShell(cmd) {
+    const shell = window.__debug?.shell;
+    if (!shell?.run) throw new Error('child_process: shell not ready');
+    let captured = '';
+    const origWrite = ctx.term.write.bind(ctx.term);
+    ctx.term.write = s => { captured += s; };
+    try { await shell.run(cmd); } finally { ctx.term.write = origWrite; }
+    return { stdout: captured.replace(/\r\n/g, '\n').replace(/\x1b\[\d+m/g, ''), code: ctx.lastExitCode | 0 };
+  }
+  return {
+    spawn: (cmd, args = [], opts = {}) => {
+      const handlers = { stdout: [], stderr: [], exit: [], close: [], error: [] };
+      const emit = (ev, ...a) => { for (const h of handlers[ev] || []) h(...a); };
+      const emitter = {
+        stdout: { on: (ev, fn) => { if (ev === 'data') handlers.stdout.push(fn); return emitter.stdout; }, pipe: () => emitter.stdout },
+        stderr: { on: (ev, fn) => { if (ev === 'data') handlers.stderr.push(fn); return emitter.stderr; } },
+        stdin: { write: () => true, end: () => {} },
+        on: (ev, fn) => { (handlers[ev] = handlers[ev] || []).push(fn); return emitter; },
+        once: (ev, fn) => emitter.on(ev, fn),
+        kill: () => {},
+        pid: Math.floor(Math.random() * 65535) + 1,
+      };
+      const line = [cmd, ...args].join(' ');
+      queueMicrotask(async () => {
+        try { const r = await runThroughShell(line); if (r.stdout) emit('stdout', r.stdout); emit('exit', r.code, null); emit('close', r.code, null); }
+        catch (e) { emit('error', e); emit('exit', 1, null); emit('close', 1, null); }
+      });
+      return emitter;
+    },
+    exec: (cmd, opts, cb) => {
+      if (typeof opts === 'function') { cb = opts; opts = {}; }
+      queueMicrotask(async () => { try { const r = await runThroughShell(cmd); cb?.(r.code === 0 ? null : Object.assign(new Error('exit ' + r.code), { code: r.code }), r.stdout, ''); } catch (e) { cb?.(e, '', String(e.message)); } });
+    },
+    execSync: cmd => { throw new Error('child_process.execSync: use exec() with callback in browser — sync subprocess impossible'); },
+    fork: () => { throw new Error('child_process.fork: not supported in browser'); },
+  };
+}
+
+export function createHttpClient(Buf) {
+  function makeReq(urlOrOpts, cb) {
+    const u = typeof urlOrOpts === 'string' ? urlOrOpts : ('http://' + (urlOrOpts.hostname || 'localhost') + ':' + (urlOrOpts.port || 80) + (urlOrOpts.path || '/'));
+    const opts = typeof urlOrOpts === 'object' ? urlOrOpts : {};
+    const handlers = { response: [], error: [], finish: [] };
+    const emit = (ev, ...a) => { for (const h of handlers[ev] || []) h(...a); };
+    let body = '';
+    const req = {
+      on: (ev, fn) => { (handlers[ev] = handlers[ev] || []).push(fn); return req; },
+      write: chunk => { body += String(chunk); return true; },
+      end: async chunk => {
+        if (chunk != null) body += String(chunk);
+        try {
+          const res = await fetch(u, { method: opts.method || 'GET', headers: opts.headers || {}, body: body || undefined });
+          const text = await res.text();
+          const resObj = {
+            statusCode: res.status, statusMessage: res.statusText, headers: Object.fromEntries(res.headers.entries()),
+            on: (ev, fn) => { if (ev === 'data') queueMicrotask(() => fn(Buf.from(text))); if (ev === 'end') queueMicrotask(() => fn()); return resObj; },
+            setEncoding: () => {}, pipe: () => {},
+          };
+          cb?.(resObj); emit('response', resObj);
+        } catch (e) { emit('error', e); }
+      },
+      setHeader: () => {}, getHeader: () => undefined, abort: () => {}, destroy: () => {},
+    };
+    return req;
+  }
+  return {
+    request: (urlOrOpts, cb) => makeReq(urlOrOpts, cb),
+    get: (urlOrOpts, cb) => { const r = makeReq(urlOrOpts, cb); r.end(); return r; },
+    Agent: class Agent {},
+    STATUS_CODES: { 200: 'OK', 201: 'Created', 204: 'No Content', 301: 'Moved Permanently', 302: 'Found', 400: 'Bad Request', 401: 'Unauthorized', 403: 'Forbidden', 404: 'Not Found', 500: 'Internal Server Error' },
+  };
+}
+
+export function extendProcess(proc, ctx) {
+  proc.execPath = '/usr/local/bin/node';
+  proc.argv0 = 'node';
+  proc.title = 'node';
+  if (!ctx.env.PATH) ctx.env.PATH = '/usr/local/bin:/usr/bin:/bin';
+  if (!ctx.env.HOME) ctx.env.HOME = '/root';
+  if (!ctx.env.USER) ctx.env.USER = 'root';
+  if (!ctx.env.SHELL) ctx.env.SHELL = '/bin/jsh';
+  if (!ctx.env.TERM) ctx.env.TERM = 'xterm-256color';
+  if (!ctx.env.LANG) ctx.env.LANG = 'C.UTF-8';
+  proc.memoryUsage = () => ({ rss: 50000000, heapTotal: 20000000, heapUsed: 10000000, external: 0, arrayBuffers: 0 });
+  proc.uptime = () => performance.now() / 1000;
+  proc.cpuUsage = () => ({ user: 0, system: 0 });
+  proc.getuid = () => 0; proc.getgid = () => 0; proc.geteuid = () => 0; proc.getegid = () => 0;
+  proc.umask = () => 0o022;
+  proc.features = { tls: false };
+  proc.release = { name: 'node', lts: false, sourceUrl: '', headersUrl: '' };
+  return proc;
+}
+
+export function rewriteStack(err, filename) {
+  if (!err.stack) return err.message;
+  const lines = err.stack.split('\n');
+  const first = lines[0];
+  const fname = filename || '[eval]';
+  const frames = lines.slice(1)
+    .filter(l => !l.includes('new Function') && !l.includes('AsyncFunction') && !l.includes('<anonymous>'))
+    .map(l => l.replace(/\bat eval \(eval at[^)]*\), /, 'at ').replace(/:(\d+):(\d+)\)?$/, (_, ln, col) => ':' + ln + ':' + col))
+    .slice(0, 5);
+  return [first, ...frames].join('\n') + '\n\nNode.js v23.10.0';
+}
+
+export function isEsmCode(code) {
+  const stripped = code.replace(/\/\*[\s\S]*?\*\//g, '').replace(/\/\/.*$/gm, '');
+  return /^\s*(import\s+[\w*{]|import\s*['"`]|export\s+(default|const|function|class|let|var|\{))/m.test(stripped);
+}
+
+export async function runEsm(code, scope) {
+  const injectionKeys = Object.keys(scope);
+  const preamble = injectionKeys.map(k => `const ${k} = globalThis.__esmScope__.${k};`).join('\n');
+  globalThis.__esmScope__ = scope;
+  const blob = new Blob([preamble + '\n' + code], { type: 'text/javascript' });
+  const url = URL.createObjectURL(blob);
+  try { return await import(url); } finally { URL.revokeObjectURL(url); }
+}
+
+export function parseDotEnv(text) {
+  const out = {};
+  for (const line of text.split(/\r?\n/)) {
+    const m = line.match(/^\s*([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*?)\s*$/);
+    if (!m) continue;
+    let v = m[2];
+    if ((v.startsWith('"') && v.endsWith('"')) || (v.startsWith("'") && v.endsWith("'"))) v = v.slice(1, -1);
+    out[m[1]] = v;
+  }
+  return out;
+}

package/docs/shell-node-ipc.js

@@ -0,0 +1,15 @@
+const CHAN='plugkit-ipc';
+
+export function makeForkIpc(proc){
+  if(typeof BroadcastChannel==='undefined')return{enabled:false};
+  const bc=new BroadcastChannel(CHAN);
+  const childId=globalThis.location?.hash==='#ipc-child'?1:0;
+  const isChild=childId>0;
+  const handlers={message:[],disconnect:[]};
+  bc.addEventListener('message',e=>{const{from,to,msg}=e.data||{};if(isChild&&to==='child'){for(const h of handlers.message)h(msg,{});}else if(!isChild&&to==='parent'){for(const h of handlers.message)h(msg,{});}});
+  proc.send=msg=>{bc.postMessage({from:isChild?'child':'parent',to:isChild?'parent':'child',msg});return true;};
+  proc.on=(ev,fn)=>{if(ev==='message'||ev==='disconnect')(handlers[ev]=handlers[ev]||[]).push(fn);return proc;};
+  proc.disconnect=()=>{bc.postMessage({from:isChild?'child':'parent',to:isChild?'parent':'child',type:'disconnect'});for(const h of handlers.disconnect)h();};
+  proc.connected=true;
+  return{enabled:true,bc,isChild};
+}

package/docs/shell-node-keyobject.js

@@ -0,0 +1,60 @@
+const pemLabel=pem=>{const m=pem.match(/-----BEGIN ([^-]+)-----/);return m?m[1]:null;};
+const pemToBytes=pem=>{const m=pem.match(/-----BEGIN [^-]+-----([\s\S]+?)-----END/);if(!m)throw new Error('invalid PEM');return Uint8Array.from(atob(m[1].replace(/\s/g,'')),c=>c.charCodeAt(0));};
+const bytesToPem=(bytes,label)=>`-----BEGIN ${label}-----\n${btoa(String.fromCharCode(...bytes)).match(/.{1,64}/g).join('\n')}\n-----END ${label}-----\n`;
+
+export function makeKeyObject(pem,type){
+  const label=pemLabel(pem);
+  const inferredType=type||(label==='PRIVATE KEY'||label==='RSA PRIVATE KEY'||label==='EC PRIVATE KEY'?'private':label==='PUBLIC KEY'?'public':'secret');
+  const bytes=pemToBytes(pem);
+  const asymType=(()=>{const s=String.fromCharCode(...bytes.slice(0,Math.min(bytes.length,80)));if(s.includes('\x2A\x86\x48\xCE\x3D\x02\x01'))return'ec';if(s.includes('\x2A\x86\x48\x86\xF7\x0D\x01\x01\x01'))return'rsa';return'unknown';})();
+  return{
+    type:inferredType,
+    asymmetricKeyType:asymType,
+    export({format='pem',type:expType}={}){
+      if(format==='pem'){const l=inferredType==='private'?'PRIVATE KEY':'PUBLIC KEY';return bytesToPem(bytes,l);}
+      if(format==='der')return bytes;
+      if(format==='jwk')throw new Error('KeyObject.export jwk: use webcrypto exportKey(\'jwk\') directly');
+      throw new Error('unsupported format: '+format);
+    },
+    toCryptoKey(){throw new Error('KeyObject.toCryptoKey: import via webcrypto.importKey instead');}
+  };
+}
+
+let x509Mod=null;let x509Promise=null;
+async function getX509(){
+  if(!x509Promise)x509Promise=import('https://esm.sh/@peculiar/x509@1.9.7/es2022/x509.mjs').then(m=>m.default||m);
+  return x509Promise;
+}
+export async function preloadX509(){x509Mod=await getX509();return x509Mod;}
+
+export class X509Certificate{
+  constructor(pem){
+    this._pem=typeof pem==='string'?pem:'-----BEGIN CERTIFICATE-----\n'+btoa(String.fromCharCode(...pem)).match(/.{1,64}/g).join('\n')+'\n-----END CERTIFICATE-----\n';
+    if(x509Mod){this._parsed=new x509Mod.X509Certificate(this._pem);}else{this._parsed=null;}
+  }
+  async _parse(){
+    if(this._parsed)return this._parsed;
+    const x509=await getX509();x509Mod=x509;
+    this._parsed=new x509.X509Certificate(this._pem);
+    return this._parsed;
+  }
+  async fingerprint256Async(){const p=await this._parse();const hash=await crypto.subtle.digest('SHA-256',p.rawData);return [...new Uint8Array(hash)].map(b=>b.toString(16).padStart(2,'0').toUpperCase()).join(':');}
+  _need(){if(!this._parsed)throw new Error('X509Certificate: call await crypto.preloadX509() once before sync access, or await cert._parse()');return this._parsed;}
+  get subject(){return this._need().subject;}
+  get issuer(){return this._need().issuer;}
+  get validFrom(){return this._need().notBefore.toISOString();}
+  get validTo(){return this._need().notAfter.toISOString();}
+  get serialNumber(){return this._need().serialNumber;}
+  get raw(){return new Uint8Array(this._need().rawData);}
+  toString(){return this._pem;}
+}
+
+export function extendKeys(cryptoMod){
+  cryptoMod.createPrivateKey=input=>{const pem=typeof input==='string'?input:input.key;return makeKeyObject(pem,'private');};
+  cryptoMod.createPublicKey=input=>{const pem=typeof input==='string'?input:input.key;return makeKeyObject(pem,'public');};
+  cryptoMod.createSecretKey=buf=>({type:'secret',symmetricKeySize:buf.length,export:()=>buf});
+  cryptoMod.X509Certificate=X509Certificate;
+  cryptoMod.KeyObject={from:pem=>makeKeyObject(pem)};
+  cryptoMod.preloadX509=preloadX509;
+  return cryptoMod;
+}