thebird 1.2.78 → 1.2.80

package/docs/shell-node-modules.js

@@ -0,0 +1,157 @@
+function serializeRoutes(routes) {
+  const out = {};
+  for (const [method, arr] of Object.entries(routes)) out[method] = arr.map(r => ({ path: r.path }));
+  return out;
+}
+
+function runFns(fns, req, res) {
+  let i = 0;
+  const next = err => {
+    if (err) { res.status?.(500).send?.(String(err)); return; }
+    const fn = fns[i++];
+    if (fn) fn(req, res, next);
+  };
+  next();
+}
+
+export function createExpress(term, fsmod) {
+  return () => {
+    const routes = { GET: [], POST: [], PUT: [], DELETE: [], USE: [] };
+    const middlewares = [];
+    const app = fn => middlewares.push(fn);
+    const addRoute = method => (p, ...fns) => routes[method].push({ path: p, fn: (req, res) => runFns([...middlewares, ...fns], req, res) });
+    app.get = addRoute('GET');
+    app.post = addRoute('POST');
+    app.put = addRoute('PUT');
+    app.delete = addRoute('DELETE');
+    app.use = (...args) => {
+      if (typeof args[0] === 'function') middlewares.push(args[0]);
+      else routes.USE.push({ path: args[0], fn: args[1] });
+    };
+    app.listen = (port, cb) => {
+      window.__debug.shell.httpHandlers[port] = { routes, middlewares };
+      navigator.serviceWorker?.controller?.postMessage({ type: 'REGISTER_ROUTES', port, routes: serializeRoutes(routes) });
+      term.write('Express listening on :' + port + '\r\n');
+      cb?.();
+    };
+    app.json = () => (req, res, next) => {
+      if (typeof req.body === 'string') try { req.body = JSON.parse(req.body); } catch {}
+      next?.();
+    };
+    app.static = dir => (req, res) => {
+      const fp = dir.replace(/\/$/, '') + req.path;
+      try { res.send(fsmod.readFileSync(fp)); } catch { res.status(404).send('Not Found'); }
+    };
+    return app;
+  };
+}
+
+export function createHttp(term) {
+  return () => ({
+    createServer(handler) {
+      const routes = { GET: [{ path: '*', fn: (req, res) => handler(req, res) }], POST: [], PUT: [], DELETE: [], USE: [] };
+      return {
+        listen(port, cb) {
+          window.__debug.shell.httpHandlers[port] = { routes, middlewares: [] };
+          term.write('http listening on :' + port + '\r\n');
+          (typeof cb === 'function' ? cb : (typeof port === 'function' ? port : null))?.();
+          return this;
+        },
+        close(cb) { cb?.(); },
+        on() { return this; },
+      };
+    },
+    request: () => { throw new Error('http.request: not supported in browser — use fetch()'); },
+    get: () => { throw new Error('http.get: not supported in browser — use fetch()'); },
+    STATUS_CODES: { 200: 'OK', 404: 'Not Found', 500: 'Internal Server Error' },
+  });
+}
+
+export function createSqlite() {
+  return class Database {
+    constructor(name) {
+      this._name = name;
+      if (!window.__sqlJs) throw new Error('sql.js not loaded');
+      this._db = new window.__sqlJs.Database();
+    }
+    prepare(sql) {
+      const db = this._db;
+      return {
+        run: (...p) => { db.run(sql, p); return { changes: 1 }; },
+        get: (...p) => { const r = db.exec(sql, p); return r[0]?.values[0] ? Object.fromEntries(r[0].columns.map((c, i) => [c, r[0].values[0][i]])) : undefined; },
+        all: (...p) => { const r = db.exec(sql, p); if (!r[0]) return []; return r[0].values.map(row => Object.fromEntries(r[0].columns.map((c, i) => [c, row[i]]))); },
+      };
+    }
+    close() {}
+  };
+}
+
+export function createConsole(term) {
+  const w = s => term.write(s + '\r\n');
+  const timers = {};
+  return {
+    log: (...a) => w(a.map(v => typeof v === 'object' ? JSON.stringify(v, null, 2) : String(v)).join(' ')),
+    error: (...a) => term.write('\x1b[31m' + a.map(String).join(' ') + '\x1b[0m\r\n'),
+    warn: (...a) => term.write('\x1b[33m' + a.map(String).join(' ') + '\x1b[0m\r\n'),
+    info: (...a) => w(a.map(String).join(' ')),
+    dir: o => w(JSON.stringify(o, null, 2)),
+    table: data => {
+      if (!Array.isArray(data)) { w(JSON.stringify(data, null, 2)); return; }
+      if (!data.length) { w('(empty)'); return; }
+      const cols = Object.keys(data[0]);
+      w(cols.join('\t'));
+      for (const row of data) w(cols.map(c => String(row[c] ?? '')).join('\t'));
+    },
+    time: label => { timers[label || 'default'] = performance.now(); },
+    timeEnd: label => {
+      const k = label || 'default';
+      const ms = timers[k] ? (performance.now() - timers[k]).toFixed(3) : 0;
+      delete timers[k];
+      w(k + ': ' + ms + 'ms');
+    },
+    assert: (cond, ...a) => { if (!cond) term.write('\x1b[31mAssertion failed: ' + a.join(' ') + '\x1b[0m\r\n'); },
+    count: (() => { const c = {}; return label => { const k = label || 'default'; c[k] = (c[k] || 0) + 1; w(k + ': ' + c[k]); }; })(),
+    clear: () => term.clear(),
+    trace: (...a) => w('Trace: ' + a.map(String).join(' ')),
+    group: () => {},
+    groupEnd: () => {},
+  };
+}
+
+export const NODE_VERSION = 'v23.10.0';
+export const NODE_VERSIONS = { node: '23.10.0', acorn: '8.14.0', ada: '3.1.3', amaro: '0.4.1', ares: '1.34.4', brotli: '1.1.0', cjs_module_lexer: '2.1.0', cldr: '46.0', icu: '76.1', llhttp: '9.2.1', modules: '131', napi: '10', nbytes: '0.1.1', ncrypto: '0.0.1', nghttp2: '1.64.0', openssl: '3.0.16', simdjson: '3.12.2', simdutf: '6.0.3', sqlite: '3.49.1', tz: '2025a', undici: '6.21.1', unicode: '16.0', uv: '1.50.0', uvwasi: '0.0.21', v8: '12.9.202.28-node.13', zlib: '1.3.0.1-motley-788cb3c', zstd: '1.5.6' };
+export const NPM_VERSION = '10.9.2';
+
+export class NodeExit extends Error { constructor(code) { super('__NodeExit:' + code); this.code = code | 0; this.__nodeExit = true; } }
+
+export function createProcess(term, ctx) {
+  const stdinHandlers = { data: [], end: [] };
+  return {
+    argv: ['node'],
+    env: ctx.env,
+    cwd: () => ctx.cwd,
+    chdir: d => { ctx.cwd = d; },
+    exit: code => { throw new NodeExit(code || 0); },
+    platform: 'linux',
+    arch: 'x64',
+    version: NODE_VERSION,
+    versions: { ...NODE_VERSIONS },
+    pid: 1,
+    ppid: 0,
+    nextTick: fn => Promise.resolve().then(fn),
+    stdout: { write: s => { term.write(String(s)); return true; }, isTTY: true, columns: 80, rows: 24 },
+    stderr: { write: s => { term.write('\x1b[31m' + String(s) + '\x1b[0m'); return true; }, isTTY: true, columns: 80, rows: 24 },
+    stdin: {
+      on: (ev, fn) => { (stdinHandlers[ev] || (stdinHandlers[ev] = [])).push(fn); return this; },
+      once: (ev, fn) => { (stdinHandlers[ev] || (stdinHandlers[ev] = [])).push(fn); },
+      _feed: buf => { if (buf) for (const h of stdinHandlers.data) h(buf); for (const h of stdinHandlers.end) h(); },
+      isTTY: false, setEncoding: () => {}, resume: () => {}, pause: () => {},
+    },
+    on: () => {},
+    off: () => {},
+    emit: () => {},
+    hrtime: Object.assign(() => [0, 0], { bigint: () => BigInt(Math.round(performance.now() * 1e6)) }),
+    exitCode: 0,
+    _stdinHandlers: stdinHandlers,
+  };
+}

package/docs/shell-node-native.js

@@ -0,0 +1,31 @@
+const NATIVE_DISPATCH={
+  'better_sqlite3.node':()=>import('https://esm.sh/sql.js@1.11.0/dist/sql-wasm.js').then(m=>{const Lib=m.default||m;return{__native:true,Database:Lib.Database||Lib};}),
+  'bcrypt_lib.node':()=>import('https://esm.sh/bcryptjs@2.4.3').then(m=>({__native:true,...(m.default||m)})),
+  'sharp.node':()=>({__native:true,resize:()=>{throw new Error('sharp native requires WASM variant — use @img/sharp-wasm32');}}),
+  'argon2.node':()=>import('https://esm.sh/argon2-browser@1.18.0').then(m=>({__native:true,hash:m.default.hash,verify:m.default.verify})),
+  'bufferutil.node':()=>({__native:true,mask:(src,mask,out,offset,length)=>{for(let i=0;i<length;i++)out[offset+i]=src[i]^mask[i&3];},unmask:(buf,mask)=>{for(let i=0;i<buf.length;i++)buf[i]^=mask[i&3];}}),
+  'utf_8_validate.node':()=>({__native:true,default:(s,buf)=>{try{new TextDecoder('utf-8',{fatal:true}).decode(buf);return true;}catch{return false;}}}),
+  'farmhash.node':()=>({__native:true,hash32:s=>{let h=2166136261;for(const c of String(s))h=Math.imul(h^c.charCodeAt(0),16777619)>>>0;return h;},hash64:s=>BigInt(NATIVE_DISPATCH['farmhash.node']().hash32(s))}),
+};
+
+export function makeNativeLoader(){
+  return{
+    async dlopen(target,path){const key=path.split('/').pop();const loader=NATIVE_DISPATCH[key];if(!loader)throw new Error(`process.dlopen: no WASM/browser equivalent for ${path}`);const mod=await loader();target.exports=mod;return target;},
+    resolve:key=>NATIVE_DISPATCH[key]?'virtual:native/'+key:null,
+    register:(name,loader)=>{NATIVE_DISPATCH[name]=loader;},
+    list:()=>Object.keys(NATIVE_DISPATCH),
+  };
+}
+
+export function wireNativeRequire(makeRequire,nativeLoader){
+  const origRequire=makeRequire;
+  return dir=>{
+    const req=origRequire(dir);
+    const wrapped=function(id){
+      if(id.endsWith('.node')){const key=id.split('/').pop();if(nativeLoader.resolve(key)){const target={exports:{}};nativeLoader.dlopen(target,id);return target.exports;}throw new Error(`Cannot find native addon: ${id}`);}
+      return req(id);
+    };
+    wrapped.resolve=req.resolve;wrapped.cache=req.cache;
+    return wrapped;
+  };
+}

package/docs/shell-node-net.js

@@ -0,0 +1,71 @@
+const relayUrl=()=>{const g=globalThis;return g.__plugkit_tcp_relay||g.window?.__plugkit_tcp_relay||null;};
+const udpRelayUrl=()=>{const g=globalThis;return g.__plugkit_udp_relay||g.window?.__plugkit_udp_relay||null;};
+
+export function makeNet(Buf){
+  class Socket{
+    constructor(){this._h={};this._ws=null;this.bufferedAmount=0;this.writable=true;this.readable=true;this.remoteAddress=null;this.remotePort=null;this.destroyed=false;}
+    _emit(ev,...a){for(const f of this._h[ev]||[])f(...a);}
+    on(ev,fn){(this._h[ev]=this._h[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._h[ev]=(this._h[ev]||[]).filter(x=>x!==fn);return this;}
+    connect(opts,listener){const{port,host='127.0.0.1',tls=false}=typeof opts==='object'?opts:{port:opts,host:arguments[1]};const relay=relayUrl();if(!relay)throw new Error('net.Socket.connect: set window.__plugkit_tcp_relay to a WSS URL that tunnels TCP — not configured');this.remoteAddress=host;this.remotePort=port;const url=`${relay}${relay.includes('?')?'&':'?'}host=${encodeURIComponent(host)}&port=${port}${tls?'&tls=1':''}`;this._ws=new WebSocket(url);this._ws.binaryType='arraybuffer';this._ws.onopen=()=>{this._emit('connect');listener&&listener();};this._ws.onmessage=e=>{this._emit('data',Buf.from(e.data instanceof ArrayBuffer?new Uint8Array(e.data):new TextEncoder().encode(String(e.data))));};this._ws.onclose=()=>{this.destroyed=true;this._emit('end');this._emit('close');};this._ws.onerror=e=>this._emit('error',e);return this;}
+    write(chunk,enc,cb){if(!this._ws||this._ws.readyState!==1){if(cb)cb(new Error('not connected'));return false;}const b=chunk instanceof Uint8Array?chunk:new TextEncoder().encode(String(chunk));this._ws.send(b);this.bufferedAmount=this._ws.bufferedAmount;if(cb)cb();return this.bufferedAmount<65536;}
+    end(chunk){if(chunk)this.write(chunk);if(this._ws)this._ws.close();}
+    destroy(err){this.destroyed=true;if(err)this._emit('error',err);if(this._ws)this._ws.close();}
+    setEncoding(){return this;}
+    setKeepAlive(){return this;}
+    setNoDelay(){return this;}
+    setTimeout(){return this;}
+    pipe(dest){this.on('data',c=>{if(dest.write(c)===false)this._ws.send('__BACKPRESSURE__');});this.on('end',()=>dest.end?.());return dest;}
+  }
+  return{
+    Socket,
+    createConnection(...args){const s=new Socket();s.connect(...args);return s;},
+    connect(...args){return this.createConnection(...args);},
+    createServer(onConn){const bn=globalThis.__busnet;if(!bn)throw new Error('net.createServer: busnet not initialized');const handlers={connection:onConn?[onConn]:[]};let bnHandle=null;return{listen(port,host,cb){if(typeof host==='function'){cb=host;host=null;}bnHandle=bn.listen(port,'tcp',c=>{for(const h of handlers.connection)h(c);});cb?.();return this;},close(cb){bnHandle?.close();cb?.();},on(ev,fn){(handlers[ev]=handlers[ev]||[]).push(fn);return this;},address(){return bnHandle?{address:'127.0.0.1',family:'IPv4',port:bnHandle.port}:null;},unref(){return this;},ref(){return this;}};},
+    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 makeTls(netMod,Buf){
+  class TLSSocket extends netMod.Socket{
+    constructor(){super();this.authorized=true;this.encrypted=true;}
+  }
+  return{
+    TLSSocket,
+    connect(opts,listener){const s=new TLSSocket();const port=typeof opts==='object'?opts.port:opts;const host=typeof opts==='object'?opts.host:arguments[1];s.connect({port,host,tls:true},listener);return s;},
+    createServer(){throw new Error('tls.createServer: server sockets not supported');},
+    DEFAULT_ECDH_CURVE:'auto',
+    DEFAULT_MAX_VERSION:'TLSv1.3',
+    DEFAULT_MIN_VERSION:'TLSv1.2',
+    CLIENT_RENEG_LIMIT:3,
+    rootCertificates:[],
+    checkServerIdentity:()=>undefined,
+    createSecureContext:()=>({}),
+  };
+}
+
+export function makeDgram(Buf){
+  class Dgram{
+    constructor(type='udp4'){this.type=type;this._h={};this._ws=null;this._addr=null;}
+    on(ev,fn){(this._h[ev]=this._h[ev]||[]).push(fn);return this;}
+    _emit(ev,...a){for(const f of this._h[ev]||[])f(...a);}
+    bind(port,addr,cb){this._addr={port:port||0,address:addr||'0.0.0.0'};queueMicrotask(()=>{this._emit('listening');cb&&cb();});const relay=udpRelayUrl();if(!relay)return;this._ws=new WebSocket(relay);this._ws.binaryType='arraybuffer';this._ws.onmessage=e=>{const view=new DataView(e.data);const srcPortLen=view.getUint16(0);const portBytes=new Uint8Array(e.data,2,srcPortLen);const addrStr=new TextDecoder().decode(portBytes);const[ah,ap]=addrStr.split(':');const payload=new Uint8Array(e.data,2+srcPortLen);this._emit('message',Buf.from(payload),{address:ah,port:+ap,family:'IPv4',size:payload.length});};return this;}
+    send(msg,offset,length,port,addr,cb){if(typeof offset==='number'&&typeof length==='number'){msg=msg.slice(offset,offset+length);}else{cb=addr;addr=port;port=length;}const relay=udpRelayUrl();if(!relay){if(cb)cb(new Error('dgram: set window.__plugkit_udp_relay'));return;}if(!this._ws){this._ws=new WebSocket(relay);this._ws.binaryType='arraybuffer';}const send=()=>{const target=`${addr}:${port}`;const tb=new TextEncoder().encode(target);const buf=new Uint8Array(2+tb.length+msg.length);new DataView(buf.buffer).setUint16(0,tb.length);buf.set(tb,2);buf.set(msg instanceof Uint8Array?msg:new TextEncoder().encode(String(msg)),2+tb.length);this._ws.send(buf);cb&&cb(null);};if(this._ws.readyState===1)send();else this._ws.addEventListener('open',send,{once:true});}
+    address(){return this._addr||{address:'0.0.0.0',port:0,family:'IPv4'};}
+    close(cb){if(this._ws)this._ws.close();this._emit('close');cb&&cb();}
+    addMembership(){}
+    dropMembership(){}
+    setBroadcast(){}
+    setTTL(){}
+    setMulticastTTL(){}
+    ref(){return this;}
+    unref(){return this;}
+  }
+  return{
+    Socket:Dgram,
+    createSocket(type,cb){const s=new Dgram(typeof type==='object'?type.type:type);if(typeof cb==='function')s.on('message',cb);return s;},
+  };
+}

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();},
+  };
+}