thebird 1.2.79 → 1.2.81

package/docs/shell-node-observe.js

@@ -0,0 +1,80 @@
+export function makeDebugRegistry(){
+  const reg={modules:{},streamsOpen:new Set(),workersActive:new Set(),cryptoOps:0,requireCount:0,zlibBytes:{in:0,out:0},http2Sessions:0,vmContexts:0,activeRequires:[]};
+  if(typeof window!=='undefined'){window.__debug=window.__debug||{};window.__debug.node=reg;}
+  return reg;
+}
+
+export function makeDiagnosticsChannel(){
+  const channels=new Map();
+  const ch=name=>{if(!channels.has(name))channels.set(name,{name,subs:new Set(),subscribe(fn){this.subs.add(fn);return this;},unsubscribe(fn){this.subs.delete(fn);return this;},publish(msg){for(const fn of this.subs)try{fn(msg,name);}catch{}},hasSubscribers(){return this.subs.size>0;}});return channels.get(name);};
+  return{
+    channel:ch,
+    subscribe(name,fn){ch(name).subscribe(fn);},
+    unsubscribe(name,fn){ch(name).unsubscribe(fn);},
+    hasSubscribers(name){return ch(name).hasSubscribers();},
+    tracingChannel(name){const start=ch(name+':start');const end=ch(name+':end');const asyncStart=ch(name+':asyncStart');const asyncEnd=ch(name+':asyncEnd');const error=ch(name+':error');return{start,end,asyncStart,asyncEnd,error,traceSync(fn,ctx){start.publish(ctx);try{const r=fn.call(ctx);end.publish({...ctx,result:r});return r;}catch(e){error.publish({...ctx,error:e});throw e;}},async tracePromise(fn,ctx){start.publish(ctx);try{const r=await fn.call(ctx);asyncEnd.publish({...ctx,result:r});return r;}catch(e){error.publish({...ctx,error:e});throw e;}}};},
+  };
+}
+
+export function makeTraceEvents(reg){
+  const events=[];
+  reg.traceEvents=events;
+  const tracings=[];
+  return{
+    createTracing({categories=[]}={}){const t={categories,enabled:false,enable(){this.enabled=true;tracings.push(this);},disable(){this.enabled=false;const i=tracings.indexOf(this);if(i>=0)tracings.splice(i,1);}};return t;},
+    getEnabledCategories(){const out=new Set();for(const t of tracings)if(t.enabled)for(const c of t.categories)out.add(c);return[...out];},
+    _emit(cat,name,data){if(events.length>=10000)events.shift();events.push({cat,name,data,ts:performance.now()});},
+  };
+}
+
+export function makeBufferPool(Buf,poolSize=8192){
+  let pool=new Uint8Array(poolSize);
+  let offset=0;
+  Buf.poolSize=poolSize;
+  const origAllocUnsafe=Buf.allocUnsafe;
+  Buf.allocUnsafe=size=>{if(size>=poolSize>>>1)return origAllocUnsafe(size);if(offset+size>poolSize){pool=new Uint8Array(poolSize);offset=0;}const slice=Buf.from(pool.buffer,pool.byteOffset+offset,size);offset+=size;offset=(offset+7)&~7;return slice;};
+  Buf.allocUnsafeSlow=size=>origAllocUnsafe(size);
+  return Buf;
+}
+
+export function makeProcessBindings(util){
+  const bindings={util:{isDate:v=>v instanceof Date,isRegExp:v=>v instanceof RegExp,isMap:v=>v instanceof Map,isSet:v=>v instanceof Set,isPromise:v=>v instanceof Promise,isNativeError:v=>v instanceof Error,isArrayBuffer:v=>v instanceof ArrayBuffer,isTypedArray:v=>ArrayBuffer.isView(v)&&!(v instanceof DataView),getHiddenValue:()=>undefined,setHiddenValue:()=>{}}};
+  return name=>{if(bindings[name])return bindings[name];throw new Error(`process.binding('${name}'): internal binding not exposed`);};
+}
+
+export function makePerfMemory(perf){
+  const getMemory=()=>{const m=performance.memory||{usedJSHeapSize:0,totalJSHeapSize:0,jsHeapSizeLimit:1073741824};return{rss:m.totalJSHeapSize||50000000,heapTotal:m.totalJSHeapSize||10000000,heapUsed:m.usedJSHeapSize||5000000,external:0,arrayBuffers:0};};
+  perf.measureUserAgentSpecificMemory=performance.measureUserAgentSpecificMemory?.bind(performance)||(async()=>({bytes:getMemory().heapUsed,breakdown:[]}));
+  return getMemory;
+}
+
+export function makeFetchPool(){
+  return class Agent{
+    constructor(opts={}){this.maxSockets=opts.maxSockets||Infinity;this.keepAlive=opts.keepAlive!==false;this._queue=[];this._active=0;this._controllers=new Set();}
+    _acquire(){if(this._active<this.maxSockets){this._active++;return Promise.resolve();}return new Promise(r=>this._queue.push(r));}
+    _release(){this._active--;const next=this._queue.shift();if(next){this._active++;next();}}
+    async fetch(url,opts={}){await this._acquire();const ctrl=new AbortController();this._controllers.add(ctrl);const signal=opts.signal?AbortSignal.any?.([opts.signal,ctrl.signal])||opts.signal:ctrl.signal;try{return await fetch(url,{...opts,signal});}finally{this._controllers.delete(ctrl);this._release();}}
+    destroy(){for(const c of this._controllers)c.abort();this._controllers.clear();}
+  };
+}
+
+export function installPrepareStackTraceHook(){
+  if(Error._psHooked)return;Error._psHooked=true;
+  const origGetStack=Object.getOwnPropertyDescriptor(Error.prototype,'stack');
+  const parseFrame=l=>{const m=l.match(/at\s+(?:(.+?)\s+\()?(.+?):(\d+):(\d+)\)?/);return m?{getFileName:()=>m[2],getLineNumber:()=>+m[3],getColumnNumber:()=>+m[4],getFunctionName:()=>m[1]||null,isNative:()=>false,isEval:()=>false,toString:()=>l.trim()}:{getFileName:()=>null,getLineNumber:()=>0,getColumnNumber:()=>0,getFunctionName:()=>null,isNative:()=>false,toString:()=>l.trim()};};
+  if(!('prepareStackTrace'in Error))Error.prepareStackTrace=null;
+  Object.defineProperty(Error.prototype,'stack',{configurable:true,get(){const raw=origGetStack?.get?.call(this)||'';if(typeof Error.prepareStackTrace==='function'){const lines=raw.split('\n').slice(1).filter(l=>l.trim().startsWith('at '));const frames=lines.map(parseFrame);try{return Error.prepareStackTrace(this,frames);}catch{return raw;}}return raw;},set(v){Object.defineProperty(this,'stack',{value:v,writable:true,configurable:true});}});
+}
+
+export function installCaptureStackTrace(){
+  if(Error.captureStackTrace)return;
+  Error.captureStackTrace=(target,ctor)=>{const e=new Error();const lines=(e.stack||'').split('\n');target.stack=(ctor?.name?ctor.name:'Error')+(target.message?': '+target.message:'')+'\n'+lines.slice(2).join('\n');};
+}
+
+export function makeFsWatchReal(getSnap){
+  const watchers=[];
+  let lastSnap=null;
+  const tick=()=>{const cur=getSnap();if(!lastSnap){lastSnap={...cur};return;}const curKeys=new Set(Object.keys(cur));const prevKeys=new Set(Object.keys(lastSnap));const changed=[];for(const k of curKeys)if(!prevKeys.has(k)||cur[k]!==lastSnap[k])changed.push({type:prevKeys.has(k)?'change':'rename',path:k});for(const k of prevKeys)if(!curKeys.has(k))changed.push({type:'rename',path:k});for(const {type,path} of changed)for(const w of watchers)if(path===w.path||(w.recursive&&path.startsWith(w.path+'/')))for(const h of w.handlers.change)h(type,path.split('/').pop());lastSnap={...cur};};
+  setInterval(tick,500);
+  return (path,opts={},listener)=>{if(typeof opts==='function'){listener=opts;opts={};}const normalized=path.replace(/^\/+/,'').replace(/\/$/,'');const handlers={change:listener?[listener]:[],error:[],close:[]};const w={path:normalized,recursive:!!opts.recursive,handlers,on:(ev,fn)=>{(handlers[ev]=handlers[ev]||[]).push(fn);return w;},close:()=>{const i=watchers.indexOf(w);if(i>=0)watchers.splice(i,1);for(const h of handlers.close)h();},ref:()=>w,unref:()=>w};watchers.push(w);return w;};
+}

package/docs/shell-node-opfs.js

@@ -0,0 +1,54 @@
+const WORKER_SRC=`
+self.addEventListener('message',async e=>{
+  const {id,op,path,data,flags}=e.data;
+  try{
+    const root=await navigator.storage.getDirectory();
+    const parts=path.replace(/^\\/+/,'').split('/');
+    const fname=parts.pop();
+    let dir=root;
+    for(const p of parts){if(!p)continue;try{dir=await dir.getDirectoryHandle(p,{create:op==='write'||op==='mkdir'});}catch(err){if(op==='read'||op==='stat'||op==='delete'){self.postMessage({id,error:'ENOENT: '+path});return;}throw err;}}
+    if(op==='mkdir'){await dir.getDirectoryHandle(fname,{create:true});self.postMessage({id,ok:true});return;}
+    if(op==='read'){const h=await dir.getFileHandle(fname);const f=await h.getFile();const buf=new Uint8Array(await f.arrayBuffer());self.postMessage({id,data:buf},[buf.buffer]);return;}
+    if(op==='write'){const h=await dir.getFileHandle(fname,{create:true});const sync=await h.createSyncAccessHandle();const bytes=data instanceof Uint8Array?data:new TextEncoder().encode(String(data));sync.truncate(0);sync.write(bytes,{at:0});sync.flush();sync.close();self.postMessage({id,ok:true});return;}
+    if(op==='stat'){const h=await dir.getFileHandle(fname).catch(()=>dir.getDirectoryHandle(fname));const f=await h.getFile?.();self.postMessage({id,size:f?.size||0,mtime:f?.lastModified||0,isFile:!!f,isDirectory:!f});return;}
+    if(op==='delete'){await dir.removeEntry(fname,{recursive:flags?.recursive||false});self.postMessage({id,ok:true});return;}
+    if(op==='list'){const out=[];for await(const [name,h] of dir.entries())out.push({name,kind:h.kind});self.postMessage({id,entries:out});return;}
+    self.postMessage({id,error:'unknown op: '+op});
+  }catch(err){self.postMessage({id,error:err.message});}
+});
+`;
+
+export function makeOpfsBackend(Buf){
+  if(typeof navigator==='undefined'||!navigator.storage?.getDirectory)return null;
+  const blob=new Blob([WORKER_SRC],{type:'application/javascript'});
+  const url=URL.createObjectURL(blob);
+  const worker=new Worker(url);
+  const pending=new Map();let nextId=1;
+  worker.addEventListener('message',e=>{const {id,...rest}=e.data;const p=pending.get(id);if(!p)return;pending.delete(id);if(rest.error)p.reject(new Error(rest.error));else p.resolve(rest);});
+  const call=(op,path,data,flags)=>new Promise((resolve,reject)=>{const id=nextId++;pending.set(id,{resolve,reject});worker.postMessage({id,op,path,data,flags});});
+  return{
+    readFile:async(path,enc)=>{const r=await call('read',path);return enc?new TextDecoder(enc==='utf-8'?'utf-8':enc).decode(r.data):Buf.from(r.data);},
+    writeFile:async(path,data)=>{await call('write',path,data);},
+    mkdir:async path=>{await call('mkdir',path);},
+    rm:async(path,opts)=>{await call('delete',path,null,opts);},
+    stat:async path=>call('stat',path),
+    list:async path=>{const r=await call('list',path);return r.entries;},
+    _worker:worker,
+    _url:url,
+  };
+}
+
+export function wireOpfsIntoFs(fs,opfs,reg){
+  if(!opfs)return fs;
+  const orig={readFileSync:fs.readFileSync,writeFileSync:fs.writeFileSync,existsSync:fs.existsSync,statSync:fs.statSync,mkdirSync:fs.mkdirSync,rmSync:fs.rmSync,unlinkSync:fs.unlinkSync};
+  fs.promises=fs.promises||{};
+  fs.promises.readFile=async(p,enc)=>opfs.readFile(p,enc).catch(()=>orig.readFileSync(p,enc));
+  fs.promises.writeFile=async(p,d)=>{await opfs.writeFile(p,d).catch(()=>orig.writeFileSync(p,d));};
+  fs.promises.mkdir=async(p,o)=>{await opfs.mkdir(p).catch(()=>orig.mkdirSync(p,o));};
+  fs.promises.rm=async(p,o)=>{await opfs.rm(p,o).catch(()=>orig.rmSync(p,o));};
+  fs.promises.stat=async p=>opfs.stat(p).catch(()=>orig.statSync(p));
+  fs.promises.readdir=async p=>opfs.list(p).then(es=>es.map(e=>e.name)).catch(()=>fs.readdirSync(p));
+  reg.polyfills=reg.polyfills||{};
+  reg.polyfills.opfs={active:true,backing:'native',reason:'OPFS available'};
+  return fs;
+}

package/docs/shell-node-procfs.js

@@ -0,0 +1,42 @@
+export function makeProcFs(proc){
+  const g=globalThis;
+  const gen={
+    'proc/self/cmdline':()=>(proc.argv||[]).join('\0')+'\0',
+    'proc/self/environ':()=>Object.entries(proc.env||{}).map(([k,v])=>`${k}=${v}`).join('\0')+'\0',
+    'proc/self/cwd':()=>proc.cwd?.()||'/',
+    'proc/self/exe':()=>proc.execPath||'/usr/local/bin/node',
+    'proc/self/status':()=>{const m=performance.memory||{usedJSHeapSize:0,totalJSHeapSize:0};return`Name:\tnode\nState:\tR (running)\nPid:\t${proc.pid||1}\nPPid:\t${proc.ppid||0}\nUid:\t0\t0\t0\t0\nGid:\t0\t0\t0\t0\nVmRSS:\t${(m.totalJSHeapSize/1024)|0} kB\nVmPeak:\t${(m.totalJSHeapSize/1024)|0} kB\n`;},
+    'proc/self/stat':()=>`${proc.pid||1} (node) R ${proc.ppid||0} ${proc.pid||1} ${proc.pid||1} 0 -1 4194304 0 0 0 0 0 0 0 0 20 0 1 0 ${performance.now()|0} ${(performance.memory?.totalJSHeapSize||0)} 0 18446744073709551615 0 0 0 0 0 0 0 0 0 0 0 0 17 0 0 0 0 0 0\n`,
+    'proc/self/maps':()=>'00400000-00500000 r-xp 00000000 00:00 0 [text]\n',
+    'proc/self/limits':()=>'Limit                     Soft Limit Hard Limit\nMax open files            1024 4096\n',
+    'proc/cpuinfo':()=>{const n=navigator?.hardwareConcurrency||4;let out='';for(let i=0;i<n;i++)out+=`processor\t: ${i}\nvendor_id\t: BrowserCPU\nmodel name\t: Browser JS Engine\ncpu MHz\t\t: 3000.000\ncache size\t: 8192 KB\ncores\t\t: ${n}\n\n`;return out;},
+    'proc/meminfo':()=>{const m=performance.memory||{totalJSHeapSize:1e9,jsHeapSizeLimit:2e9,usedJSHeapSize:5e8};return`MemTotal:       ${(m.jsHeapSizeLimit/1024)|0} kB\nMemFree:        ${((m.jsHeapSizeLimit-m.usedJSHeapSize)/1024)|0} kB\nMemAvailable:   ${((m.jsHeapSizeLimit-m.usedJSHeapSize)/1024)|0} kB\nBuffers:               0 kB\nCached:                0 kB\n`;},
+    'proc/uptime':()=>`${(performance.now()/1000).toFixed(2)} ${(performance.now()/1000).toFixed(2)}\n`,
+    'proc/loadavg':()=>'0.00 0.00 0.00 1/1 '+(proc.pid||1)+'\n',
+    'proc/version':()=>`Linux version 6.0.0-browser (node@thebird) #1 SMP ${new Date().toUTCString()}\n`,
+    'proc/stat':()=>'cpu  0 0 0 0 0 0 0 0 0 0\nbtime '+Math.floor(Date.now()/1000)+'\n',
+    'proc/mounts':()=>'idbfs / idbfs rw,relatime 0 0\n',
+    'proc/filesystems':()=>'nodev\tidbfs\nnodev\topfs\n',
+    'etc/hosts':()=>'127.0.0.1 localhost\n::1 localhost\n',
+    'etc/resolv.conf':()=>'nameserver 1.1.1.1\nnameserver 8.8.8.8\n',
+    'etc/passwd':()=>'root:x:0:0:root:/root:/bin/sh\n',
+    'etc/group':()=>'root:x:0:\n',
+    'etc/os-release':()=>'NAME="thebird"\nPRETTY_NAME="thebird browser runtime"\nID=thebird\nID_LIKE=linux\nVERSION_ID="1.0"\n',
+    'etc/hostname':()=>'thebird\n',
+    'etc/machine-id':()=>'00000000000000000000000000000000\n',
+    'etc/shells':()=>'/bin/sh\n/bin/bash\n',
+  };
+  return{
+    handles(path){const k=path.replace(/^\//,'').replace(/\/$/,'');return k in gen;},
+    read(path){const k=path.replace(/^\//,'').replace(/\/$/,'');const fn=gen[k];if(!fn)return null;try{return fn();}catch{return'';}},
+    list(){return Object.keys(gen).map(k=>'/'+k);},
+  };
+}
+
+export function wireProcFs(fs,procFs){
+  const origRead=fs.readFileSync, origExists=fs.existsSync, origStat=fs.statSync;
+  fs.readFileSync=(p,enc)=>{if(procFs.handles(p)){const s=procFs.read(p);return enc?s:new TextEncoder().encode(s);}return origRead(p,enc);};
+  fs.existsSync=p=>procFs.handles(p)||origExists(p);
+  fs.statSync=p=>{if(procFs.handles(p)){const s=procFs.read(p);return{size:s.length,mode:0o100444,isFile:()=>true,isDirectory:()=>false,isSymbolicLink:()=>false,isFIFO:()=>false,isBlockDevice:()=>false,isCharacterDevice:()=>false,isSocket:()=>false,mtimeMs:Date.now(),mtime:new Date(),atimeMs:Date.now(),ctimeMs:Date.now(),birthtimeMs:Date.now(),uid:0,gid:0,nlink:1,dev:0,ino:0,rdev:0,blksize:4096,blocks:1};}return origStat(p);};
+  return fs;
+}

package/docs/shell-node-profiler.js

@@ -0,0 +1,50 @@
+export function makeV8Profiler(debugReg){
+  const samples=[];let observer=null;let running=false;let startT=0;
+  const startObserver=()=>{if(observer||typeof PerformanceObserver==='undefined')return;try{observer=new PerformanceObserver(list=>{for(const e of list.getEntries())if(running)samples.push({name:e.name,ts:e.startTime,dur:e.duration,entryType:e.entryType});});observer.observe({entryTypes:['measure','longtask','function']});}catch{}};
+  const stopObserver=()=>{if(observer){observer.disconnect();observer=null;}};
+  return{
+    CPUProfile:class CPUProfile{
+      constructor(){this.nodes=[];this.samples=[];this.timeDeltas=[];this.startTime=0;this.endTime=0;this.title='';}
+      startProfiling(title){this.title=title||'';samples.length=0;startT=performance.now();running=true;startObserver();}
+      stopProfiling(){running=false;stopObserver();const end=performance.now();this.startTime=startT*1000;this.endTime=end*1000;this.nodes=samples.map((s,i)=>({id:i+1,callFrame:{functionName:s.name||'(anonymous)',scriptId:'0',url:'',lineNumber:0,columnNumber:0},hitCount:1,children:[]}));this.samples=samples.map((_,i)=>i+1);this.timeDeltas=samples.map(s=>Math.round(s.dur*1000));return this;}
+    },
+    startProfiling(){const p=new this.CPUProfile();p.startProfiling();return p;},
+    stopProfiling(p){return p?p.stopProfiling():null;},
+    getHeapStatistics(){const m=performance.memory||{usedJSHeapSize:5e6,totalJSHeapSize:10e6,jsHeapSizeLimit:1e9};return{total_heap_size:m.totalJSHeapSize,total_heap_size_executable:0,total_physical_size:m.totalJSHeapSize,total_available_size:m.jsHeapSizeLimit-m.usedJSHeapSize,used_heap_size:m.usedJSHeapSize,heap_size_limit:m.jsHeapSizeLimit,malloced_memory:0,peak_malloced_memory:0,does_zap_garbage:0,number_of_native_contexts:1,number_of_detached_contexts:0};},
+    getHeapSpaceStatistics(){return[{space_name:'new_space',space_size:1e6,space_used_size:5e5,space_available_size:5e5,physical_space_size:1e6}];},
+    getHeapCodeStatistics(){return{code_and_metadata_size:0,bytecode_and_metadata_size:0,external_script_source_size:0};},
+    cachedDataVersionTag:()=>0,
+    setFlagsFromString(){},
+    startupSnapshot:{isBuildingSnapshot:()=>false,addSerializeCallback(){},addDeserializeCallback(){}},
+  };
+}
+
+export function makeHeapSnapshot(){
+  const NODE_FIELDS=['type','name','id','self_size','edge_count','trace_node_id','detachedness'];
+  const NODE_TYPES=[['hidden','array','string','object','code','closure','regexp','number','native','synthetic','concatenated string','sliced string','symbol','bigint','object shape'],'string','number','number','number','number','number'];
+  const EDGE_FIELDS=['type','name_or_index','to_node'];
+  const EDGE_TYPES=[['context','element','property','internal','hidden','shortcut','weak'],'string_or_number','node'];
+  const META={node_fields:NODE_FIELDS,node_types:NODE_TYPES,edge_fields:EDGE_FIELDS,edge_types:EDGE_TYPES,trace_function_info_fields:[],trace_node_fields:[],sample_fields:[],location_fields:[]};
+  const walk=(root,maxNodes=5000)=>{
+    const visited=new WeakMap();const strings=[''];const stringIdx=new Map([['',0]]);
+    const addStr=s=>{if(stringIdx.has(s))return stringIdx.get(s);const i=strings.length;strings.push(s);stringIdx.set(s,i);return i;};
+    const nodes=[];const edges=[];const queue=[[root,'root']];
+    while(queue.length&&nodes.length<maxNodes){
+      const [obj,name]=queue.shift();
+      const isObj=obj!==null&&(typeof obj==='object'||typeof obj==='function');
+      if(isObj&&visited.has(obj))continue;
+      const id=nodes.length+1;if(isObj)visited.set(obj,id);
+      const t=obj===null?9:typeof obj==='string'?2:typeof obj==='number'?7:typeof obj==='bigint'?13:typeof obj==='symbol'?12:Array.isArray(obj)?1:typeof obj==='function'?5:3;
+      let childEdges=0;
+      if(isObj){try{for(const k of Object.keys(obj).slice(0,32)){queue.push([obj[k],k]);childEdges++;}}catch{}}
+      nodes.push([t,addStr(name),id,typeof obj==='string'?obj.length:64,childEdges,0,0]);
+    }
+    let cursor=0;
+    for(const n of nodes){const childCount=n[4];for(let i=0;i<childCount;i++){edges.push([2,cursor+i+1,(cursor+i+1)*NODE_FIELDS.length]);}cursor+=childCount;}
+    return{snapshot:{meta:META,node_count:nodes.length,edge_count:edges.length,trace_function_count:0},nodes:nodes.flat(),edges:edges.flat(),trace_function_infos:[],trace_tree:[],samples:[],locations:[],strings};
+  };
+  return{
+    writeHeapSnapshot(filename){const snap=walk(globalThis);const json=JSON.stringify(snap);if(typeof filename==='string'&&globalThis.window?.__debug?.idbSnapshot){globalThis.window.__debug.idbSnapshot[filename.replace(/^\/+/,'')]=json;}return filename;},
+    getHeapSnapshot(){const snap=walk(globalThis);return{read(){return JSON.stringify(snap);}};},
+  };
+}

package/docs/shell-node-registry.js

@@ -0,0 +1,24 @@
+const ESM_API='https://esm.sh';
+const cache=new Map();
+
+async function esmMeta(name){
+  if(cache.has(name))return cache.get(name);
+  try{
+    const url=`${ESM_API}/${name}/package.json`;
+    const r=await fetch(url);
+    if(!r.ok)throw new Error('not found');
+    const pj=await r.json();
+    cache.set(name,pj);return pj;
+  }catch(e){throw new Error(`registry: cannot fetch ${name} — ${e.message}`);}
+}
+
+export function makeRegistry(){
+  return{
+    async view(spec){const[name,field]=spec.split(/\s+/);const pj=await esmMeta(name);if(field){const parts=field.split('.');let v=pj;for(const p of parts)v=v?.[p];return v;}return pj;},
+    async search(q){try{const r=await fetch(`https://registry.npmjs.org/-/v1/search?text=${encodeURIComponent(q)}&size=10`);const j=await r.json();return j.objects?.map(o=>({name:o.package.name,version:o.package.version,description:o.package.description}))||[];}catch{return[];}},
+    async deps(name,version='latest'){try{const pj=await esmMeta(version==='latest'?name:`${name}@${version}`);return{dependencies:pj.dependencies||{},devDependencies:pj.devDependencies||{},peerDependencies:pj.peerDependencies||{}};}catch{return{dependencies:{},devDependencies:{},peerDependencies:{}};}},
+    async tarballUrl(name,version){const pj=await esmMeta(`${name}@${version}`);return`https://registry.npmjs.org/${name}/-/${name.split('/').pop()}-${pj.version}.tgz`;},
+    async fetchTarball(name,version){const url=await this.tarballUrl(name,version);const r=await fetch(url);return new Uint8Array(await r.arrayBuffer());},
+    clearCache(){cache.clear();},
+  };
+}

package/docs/shell-node-resolve.js

@@ -0,0 +1,147 @@
+const toKey = p => p.replace(/^\//, '');
+
+const CONDITIONS = ['node', 'import', 'require', 'default', 'browser'];
+function pickCondition(cond) {
+  if (typeof cond === 'string') return cond;
+  if (Array.isArray(cond)) { for (const c of cond) { const r = pickCondition(c); if (r) return r; } return null; }
+  if (!cond || typeof cond !== 'object') return null;
+  for (const k of CONDITIONS) if (k in cond) { const r = pickCondition(cond[k]); if (r) return r; }
+  return null;
+}
+function matchPattern(patternKey, target) {
+  if (!patternKey.includes('*')) return null;
+  const [pre, post] = patternKey.split('*');
+  if (target.startsWith(pre) && target.endsWith(post)) return target.slice(pre.length, target.length - post.length);
+  return null;
+}
+export function resolveExports(pkgJson, subpath) {
+  const exp = pkgJson.exports;
+  if (!exp) return null;
+  if (typeof exp === 'string') return subpath === '.' ? exp : null;
+  const key = subpath === '.' ? '.' : './' + subpath.replace(/^\.\//, '');
+  if (exp[key]) return pickCondition(exp[key]);
+  if (subpath === '.' && !('.' in exp) && !Object.keys(exp).some(k => k.startsWith('.'))) return pickCondition(exp);
+  for (const pk of Object.keys(exp)) { const m = matchPattern(pk, key); if (m !== null) { const t = pickCondition(exp[pk]); return t ? t.replace('*', m) : null; } }
+  return null;
+}
+export function rewriteSpecifier(id) {
+  if (id.startsWith('jsr:')) return 'https://esm.sh/jsr/' + id.slice(4);
+  if (id.startsWith('npm:')) return 'https://esm.sh/' + id.slice(4);
+  if (id.startsWith('https://') || id.startsWith('http://')) return id;
+  return null;
+}
+
+export function resolveImports(pkgJson, subpath) {
+  const imps = pkgJson.imports;
+  if (!imps || !subpath.startsWith('#')) return null;
+  if (imps[subpath]) return pickCondition(imps[subpath]);
+  for (const pk of Object.keys(imps)) { const m = matchPattern(pk, subpath); if (m !== null) { const t = pickCondition(imps[pk]); return t ? t.replace('*', m) : null; } }
+  return null;
+}
+
+export function walkUpNodeModules(snap, startDir, pkgName) {
+  let dir = startDir.replace(/\/$/, '') || '/';
+  while (true) {
+    const candidate = (dir === '/' ? '' : dir) + '/node_modules/' + pkgName;
+    const candKey = toKey(candidate);
+    if ((candKey + '/package.json') in snap || (candKey + '/index.js') in snap || (candKey + '.js') in snap) return candidate;
+    if (dir === '/' || dir === '') return null;
+    const up = dir.slice(0, dir.lastIndexOf('/')) || '/';
+    if (up === dir) return null;
+    dir = up;
+  }
+}
+
+export function resolvePackageEntry(snap, pkgDir) {
+  const pjKey = toKey(pkgDir) + '/package.json';
+  if (!(pjKey in snap)) return null;
+  let pj;
+  try { pj = JSON.parse(snap[pjKey]); } catch { return null; }
+  const resolved = resolveExports(pj, '.');
+  if (resolved) return pkgDir + '/' + resolved.replace(/^\.\//, '');
+  return pkgDir + '/' + (pj.main || 'index.js').replace(/^\.\//, '');
+}
+
+export function makeModuleModule(requireFn, MODULES) {
+  return {
+    builtinModules: Object.keys(MODULES).filter(k => !k.startsWith('node:')).sort(),
+    createRequire: () => requireFn,
+    _resolveFilename: (id, parent) => requireFn.resolve(id),
+    _cache: requireFn.cache,
+    _pathCache: {},
+    Module: class Module { constructor(id) { this.id = id; this.exports = {}; this.filename = id; this.loaded = false; this.children = []; this.paths = []; } },
+    syncBuiltinESMExports: () => {},
+    wrap: s => '(function (exports, require, module, __filename, __dirname) { ' + s + '\n});',
+    wrapper: ['(function (exports, require, module, __filename, __dirname) { ', '\n});'],
+  };
+}
+
+export function makeModuleNotFoundError(id, requireStack) {
+  const err = new Error("Cannot find module '" + id + "'" + (requireStack ? '\nRequire stack:\n- ' + requireStack.join('\n- ') : ''));
+  err.code = 'MODULE_NOT_FOUND';
+  err.requireStack = requireStack || [];
+  return err;
+}
+
+export function makeFsPromises(fsSync) {
+  const wrap = fn => async (...args) => fn(...args);
+  return {
+    readFile: async (p, enc) => fsSync.readFileSync(p, enc),
+    writeFile: async (p, d) => fsSync.writeFileSync(p, d),
+    appendFile: async (p, d) => fsSync.appendFileSync(p, d),
+    access: async p => fsSync.accessSync(p),
+    stat: async p => fsSync.statSync(p),
+    readdir: async p => fsSync.readdirSync(p),
+    mkdir: async (p, o) => fsSync.mkdirSync(p, o),
+    rm: async (p, o) => fsSync.rmSync(p, o),
+    rmdir: async (p, o) => fsSync.rmdirSync(p, o),
+    unlink: async p => fsSync.unlinkSync(p),
+    rename: async (o, n) => fsSync.renameSync(o, n),
+    copyFile: async (s, d) => fsSync.copyFileSync(s, d),
+    realpath: async p => fsSync.realpathSync(p),
+    open: async p => ({ close: async () => {}, readFile: async enc => fsSync.readFileSync(p, enc), writeFile: async d => fsSync.writeFileSync(p, d) }),
+  };
+}
+
+export function makeFsWatch() {
+  return (path, opts, listener) => {
+    if (typeof opts === 'function') { listener = opts; opts = {}; }
+    const handlers = { change: listener ? [listener] : [], error: [], close: [] };
+    const w = {
+      on: (ev, fn) => { (handlers[ev] = handlers[ev] || []).push(fn); return w; },
+      close: () => { for (const h of handlers.close) h(); },
+      ref: () => w, unref: () => w,
+    };
+    return w;
+  };
+}
+
+export function makeNetStub() {
+  return {
+    Socket: class Socket { constructor() { throw new Error('net.Socket: not supported in browser — use fetch() or WebSocket'); } },
+    createServer: () => { throw new Error('net.createServer: not supported in browser — use express via http builtin'); },
+    connect: () => { throw new Error('net.connect: not supported in browser'); },
+    isIP: ip => /^\d+\.\d+\.\d+\.\d+$/.test(ip) ? 4 : ip.includes(':') ? 6 : 0,
+    isIPv4: ip => /^\d+\.\d+\.\d+\.\d+$/.test(ip),
+    isIPv6: ip => ip.includes(':'),
+  };
+}
+
+export function makeDgramStub() {
+  return {
+    createSocket: () => { throw new Error('dgram.createSocket: UDP not available in browser'); },
+    Socket: class { constructor() { throw new Error('dgram.Socket: UDP not available in browser'); } },
+  };
+}
+
+export function makeWorkerThreadsStub() {
+  return {
+    Worker: class { constructor() { throw new Error('worker_threads.Worker: not supported — use Web Worker via new Worker(url)'); } },
+    isMainThread: true,
+    parentPort: null,
+    workerData: null,
+    threadId: 0,
+    MessageChannel: globalThis.MessageChannel,
+    MessagePort: globalThis.MessagePort,
+  };
+}

package/docs/shell-node-runtime.js

@@ -0,0 +1,83 @@
+export function makeWorkerThreads(snap,Buf){
+  class Worker{
+    constructor(scriptPath,opts={}){
+      const src=snap()[scriptPath.replace(/^\.?\//,'')]||scriptPath;
+      const preamble=`const workerData=${JSON.stringify(opts.workerData||null)};const parentPort={postMessage:(m,t)=>self.postMessage(m,t),on:(ev,fn)=>{if(ev==='message')self.addEventListener('message',e=>fn(e.data));if(ev==='close')self.addEventListener('close',fn);},close:()=>self.close()};`;
+      const blob=new Blob([preamble+'\n'+src],{type:'application/javascript'});
+      this._url=URL.createObjectURL(blob);
+      this._worker=new globalThis.Worker(this._url,{type:'module'});
+      this._handlers={message:[],error:[],exit:[],online:[]};
+      this._worker.addEventListener('message',e=>{for(const f of this._handlers.message)f(e.data);});
+      this._worker.addEventListener('error',e=>{for(const f of this._handlers.error)f(e);});
+      queueMicrotask(()=>{for(const f of this._handlers.online)f();});
+      this.threadId=Math.floor(Math.random()*1e9);
+    }
+    on(ev,fn){(this._handlers[ev]=this._handlers[ev]||[]).push(fn);return this;}
+    once(ev,fn){const w=(...a)=>{this.off(ev,w);fn(...a);};return this.on(ev,w);}
+    off(ev,fn){this._handlers[ev]=(this._handlers[ev]||[]).filter(x=>x!==fn);return this;}
+    postMessage(msg,transfer){this._worker.postMessage(msg,transfer);}
+    terminate(){this._worker.terminate();URL.revokeObjectURL(this._url);for(const f of this._handlers.exit)f(0);return Promise.resolve(0);}
+    ref(){return this;}
+    unref(){return this;}
+  }
+  return{
+    Worker,
+    isMainThread:true,
+    parentPort:null,
+    workerData:null,
+    threadId:0,
+    MessageChannel:globalThis.MessageChannel,
+    MessagePort:globalThis.MessagePort,
+    BroadcastChannel:globalThis.BroadcastChannel,
+    SHARE_ENV:Symbol('SHARE_ENV'),
+    setEnvironmentData(){},
+    getEnvironmentData(){},
+    markAsUntransferable(){},
+    moveMessagePortToContext(){throw new Error('moveMessagePortToContext: not supported');},
+    resourceLimits:{maxOldGenerationSizeMb:0,maxYoungGenerationSizeMb:0,codeRangeSizeMb:0,stackSizeMb:0},
+  };
+}
+
+export function makeChildProcessReal(Buf,streamMod){
+  const getWc=()=>globalThis.__webcontainer||window.__webcontainer||null;
+  const mkProc=async(cmd,args,opts={})=>{const wc=getWc();if(!wc)throw new Error('child_process: WebContainer not available — spawn requires window.__webcontainer');const p=await wc.spawn(cmd,args||[],{cwd:opts.cwd,env:opts.env});const handlers={exit:[],close:[],error:[]};const stdout=new streamMod.Readable();const stderr=new streamMod.Readable();p.output.pipeTo(new WritableStream({write(chunk){stdout.push(Buf.from(chunk));}}));const exitPromise=p.exit.then(code=>{stdout.push(null);stderr.push(null);for(const f of handlers.exit)f(code);for(const f of handlers.close)f(code);return code;});return{pid:Math.floor(Math.random()*1e6),stdout,stderr,stdin:{write:d=>p.input.getWriter().write(d),end:()=>{}},on(ev,fn){(handlers[ev]=handlers[ev]||[]).push(fn);return this;},kill(){p.kill?.();},exitPromise};};
+  return{
+    exec(cmd,opts,cb){if(typeof opts==='function'){cb=opts;opts={};}const parts=cmd.split(/\s+/);mkProc(parts[0],parts.slice(1),opts).then(p=>{const chunks=[];p.stdout.on('data',c=>chunks.push(c));p.exitPromise.then(code=>{const out=Buf.concat(chunks).toString();if(cb)code===0?cb(null,out,''):cb(Object.assign(new Error('exit '+code),{code}),out,'');});},e=>cb&&cb(e));},
+    spawn(cmd,args,opts){let proc=null;const emitter={on(){return this;},_pending:true};mkProc(cmd,args,opts).then(p=>{proc=p;Object.assign(emitter,p);},e=>{for(const f of emitter._errorHandlers||[])f(e);});return new Proxy(emitter,{get(t,k){return proc?proc[k]:t[k];}});},
+    execFile(f,args,opts,cb){if(typeof opts==='function'){cb=opts;opts={};}return this.exec([f,...(args||[])].join(' '),opts,cb);},
+    execSync(){throw new Error('child_process.execSync: synchronous subprocess not available in browser');},
+    spawnSync(){throw new Error('child_process.spawnSync: synchronous subprocess not available');},
+    fork(){throw new Error('child_process.fork: not supported — use Worker');},
+  };
+}
+
+export function makeRepl(ctx,term,nodeEval){
+  const history=[];
+  let buffer='';
+  let lastResult=undefined;
+  const commands={
+    '.clear':()=>{buffer='';term.write('\r\n');},
+    '.exit':()=>{throw Object.assign(new Error('repl exit'),{__nodeExit:true,code:0});},
+    '.help':()=>{term.write('Commands: .clear .exit .help .load .save .editor\r\n');},
+    '.load':async path=>{const snap=window.__debug?.idbSnapshot||{};const content=snap[path.replace(/^\/+/,'')];if(!content)throw new Error('file not found: '+path);return nodeEval(content);},
+    '.save':path=>{const snap=window.__debug?.idbSnapshot||{};window.__debug.idbSnapshot={...snap,[path.replace(/^\/+/,'')]:history.join('\n')};term.write('saved\r\n');},
+    '.editor':()=>{term.write('(type ^D to execute, ^C to cancel)\r\n');buffer='__editor__';},
+  };
+  const isIncomplete=code=>{let depth=0,inStr=null,inTmpl=false,prev='';for(let i=0;i<code.length;i++){const c=code[i];if(inStr){if(c==='\\'){i++;continue;}if(c===inStr)inStr=null;continue;}if(inTmpl){if(c==='\\'){i++;continue;}if(c==='`')inTmpl=false;else if(c==='$'&&code[i+1]==='{'){depth++;i++;}continue;}if(c==="'"||c==='"')inStr=c;else if(c==='`')inTmpl=true;else if(c==='('||c==='['||c==='{')depth++;else if(c===')'||c===']'||c==='}')depth--;prev=c;}return depth>0||inStr!==null||inTmpl;};
+  return{
+    commands,
+    isIncomplete,
+    async eval(line){
+      const trimmed=line.trim();
+      if(trimmed.startsWith('.')){const[cmd,...rest]=trimmed.split(/\s+/);if(commands[cmd])return commands[cmd](rest.join(' '));}
+      buffer=buffer?buffer+'\n'+line:line;
+      if(isIncomplete(buffer))return{continuation:true};
+      const code=buffer;buffer='';
+      history.unshift(code);if(history.length>1000)history.pop();
+      const src='const _=arguments[0];'+(code.startsWith('var ')||code.startsWith('let ')||code.startsWith('const ')||code.includes(';')||code.includes('\n')?code:'return ('+code+');');
+      try{const fn=new Function(src);const r=fn(lastResult);if(r!==undefined)lastResult=r;return{result:r};}catch(e){return{error:e};}
+    },
+    getHistory(){return history;},
+    get lastResult(){return lastResult;},
+  };
+}

package/docs/shell-node-srcmap.js

@@ -0,0 +1,52 @@
+let smMod=null;let smPromise=null;const consumers=new Map();const CAP=5;
+
+async function loadSm(){
+  if(!smPromise)smPromise=import('https://esm.sh/source-map-js@1.2.1/es2022/source-map-js.mjs').then(m=>m.default||m);
+  return smPromise;
+}
+
+export async function preloadSourceMap(){smMod=await loadSm();return smMod;}
+
+async function consumerFor(url,snapFn){
+  if(consumers.has(url))return consumers.get(url);
+  if(consumers.size>50){const first=consumers.keys().next().value;consumers.delete(first);}
+  if(!smMod)await loadSm();
+  let src='';
+  try{
+    if(url.startsWith('data:application/json;base64,'))src=atob(url.slice(29));
+    else if(url.startsWith('data:application/json,'))src=decodeURIComponent(url.slice(22));
+    else if(url.startsWith('http'))src=await (await fetch(url)).text();
+    else{const snap=snapFn();const key=url.replace(/^file:\/\/\/?/,'').replace(/^\//,'');src=snap[key]||snap[key+'.map']||'';}
+  }catch{return null;}
+  if(!src)return null;
+  try{const raw=JSON.parse(src);const c=new smMod.SourceMapConsumer(raw);consumers.set(url,c);return c;}catch{return null;}
+}
+
+function extractMapUrl(source){
+  if(!source)return null;
+  const m=source.match(/\/\/[#@]\s*sourceMappingURL=(\S+)/);
+  return m?m[1]:null;
+}
+
+export function installSourceMapStacks(snapFn){
+  if(Error._smHooked)return;Error._smHooked=true;
+  const origFormatter=Error.prepareStackTrace;
+  Error.prepareStackTrace=(err,frames)=>{
+    if(!smMod)return origFormatter?origFormatter(err,frames):err.toString()+'\n'+frames.map(f=>'    at '+f.toString()).join('\n');
+    let depth=0;
+    const mapped=frames.map(f=>{
+      if(depth>=CAP)return f;
+      const file=f.getFileName?.();if(!file)return f;
+      const snap=snapFn();const src=snap[file.replace(/^file:\/\/\/?/,'').replace(/^\//,'')]||'';
+      const mapUrl=extractMapUrl(src);if(!mapUrl)return f;
+      depth++;
+      const c=consumers.get(mapUrl);if(!c)return f;
+      const line=f.getLineNumber?.(),col=f.getColumnNumber?.();if(!line)return f;
+      try{const orig=c.originalPositionFor({line,column:col||0});if(!orig.source)return f;return{...f,getFileName:()=>orig.source,getLineNumber:()=>orig.line,getColumnNumber:()=>orig.column,getFunctionName:()=>orig.name||f.getFunctionName?.(),toString:()=>`    at ${orig.name||'<anonymous>'} (${orig.source}:${orig.line}:${orig.column})`};}catch{return f;}
+    });
+    return origFormatter?origFormatter(err,mapped):err.toString()+'\n'+mapped.map(f=>'    at '+(f.toString?.()||f)).join('\n');
+  };
+  Promise.resolve().then(async()=>{await loadSm();const snap=snapFn();for(const [key,src] of Object.entries(snap)){const mapUrl=extractMapUrl(src);if(mapUrl)await consumerFor(mapUrl,snapFn);}});
+}
+
+export function clearSourceMapCache(){consumers.clear();}