thebird 1.2.79 → 1.2.80

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;
+}

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