thebird 1.2.78 → 1.2.80

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

package/docs/shell-node-stdlib.js

@@ -0,0 +1,103 @@
+const COLORS = { string: '\x1b[32m', number: '\x1b[33m', boolean: '\x1b[33m', bigint: '\x1b[33m', null: '\x1b[1m', undefined: '\x1b[90m', symbol: '\x1b[35m', regexp: '\x1b[31m', date: '\x1b[35m', special: '\x1b[36m' };
+const RESET = '\x1b[0m';
+const paint = (s, c, on) => on ? c + s + RESET : s;
+
+function inspectPrimitive(v, colors) {
+  if (v === null) return paint('null', COLORS.null, colors);
+  if (v === undefined) return paint('undefined', COLORS.undefined, colors);
+  const t = typeof v;
+  if (t === 'string') return paint("'" + v.replace(/\\/g, '\\\\').replace(/'/g, "\\'") + "'", COLORS.string, colors);
+  if (t === 'bigint') return paint(String(v) + 'n', COLORS.bigint, colors);
+  if (t === 'number' || t === 'boolean') return paint(String(v), COLORS[t], colors);
+  if (t === 'symbol') return paint(v.toString(), COLORS.symbol, colors);
+  if (t === 'function') return paint('[Function' + (v.name ? ': ' + v.name : ' (anonymous)') + ']', COLORS.special, colors);
+  return null;
+}
+
+export function inspect(v, opts = {}, depth = 0, seen = new Map(), refCount = { n: 0 }) {
+  const colors = !!opts.colors;
+  const prim = inspectPrimitive(v, colors);
+  if (prim !== null) return prim;
+  if (v instanceof Date) return paint(v.toISOString(), COLORS.date, colors);
+  if (v instanceof RegExp) return paint(v.toString(), COLORS.regexp, colors);
+  if (v instanceof Error) return v.stack || (v.name + ': ' + v.message);
+  if (seen.has(v)) { const id = seen.get(v); if (id.ref == null) id.ref = ++refCount.n; return '[Circular *' + id.ref + ']'; }
+  const entry = { ref: null }; seen.set(v, entry);
+  const maxDepth = opts.depth ?? 2;
+  if (depth > maxDepth) return Array.isArray(v) ? '[Array]' : '[Object]';
+  if (Array.isArray(v)) {
+    if (!v.length) return '[]';
+    return '[ ' + v.map(x => inspect(x, opts, depth + 1, seen, refCount)).join(', ') + ' ]';
+  }
+  if (v instanceof Map) {
+    const entries = [...v.entries()].map(([k, val]) => inspect(k, opts, depth + 1, seen, refCount) + ' => ' + inspect(val, opts, depth + 1, seen, refCount));
+    return 'Map(' + v.size + ')' + (v.size ? ' { ' + entries.join(', ') + ' }' : ' {}');
+  }
+  if (v instanceof Set) {
+    const items = [...v].map(x => inspect(x, opts, depth + 1, seen, refCount));
+    return 'Set(' + v.size + ')' + (v.size ? ' { ' + items.join(', ') + ' }' : ' {}');
+  }
+  if (v instanceof Uint8Array) {
+    const hex = [...v.slice(0, 16)].map(b => b.toString(16).padStart(2, '0')).join(' ');
+    return '<Buffer ' + hex + (v.length > 16 ? ' ... ' + (v.length - 16) + ' more bytes' : '') + '>';
+  }
+  const keys = opts.showHidden ? Object.getOwnPropertyNames(v) : Object.keys(v);
+  const syms = Object.getOwnPropertySymbols(v);
+  if (!keys.length && !syms.length) return '{}';
+  const parts = keys.map(k => {
+    const ks = /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(k) ? k : "'" + k + "'";
+    return ks + ': ' + inspect(v[k], opts, depth + 1, seen, refCount);
+  }).concat(syms.map(s => '[' + s.toString() + ']: ' + inspect(v[s], opts, depth + 1, seen, refCount)));
+  const ctor = v.constructor && v.constructor !== Object ? v.constructor.name + ' ' : '';
+  const body = ctor + '{ ' + parts.join(', ') + ' }';
+  return entry.ref != null ? '<ref *' + entry.ref + '> ' + body : body;
+}
+
+export function format(...args) {
+  if (!args.length) return '';
+  const fmt = args[0];
+  if (typeof fmt !== 'string') return args.map(a => typeof a === 'object' ? inspect(a) : String(a)).join(' ');
+  let i = 1;
+  const out = fmt.replace(/%[sdifjoO%]/g, m => {
+    if (m === '%%') return '%';
+    if (i >= args.length) return m;
+    const a = args[i++];
+    if (m === '%s') return String(a);
+    if (m === '%d' || m === '%i') return String(parseInt(a, 10));
+    if (m === '%f') return String(parseFloat(a));
+    if (m === '%j') return JSON.stringify(a);
+    if (m === '%o' || m === '%O') return inspect(a);
+    return m;
+  });
+  const extra = args.slice(i).map(a => typeof a === 'object' ? inspect(a) : String(a));
+  return extra.length ? out + ' ' + extra.join(' ') : out;
+}
+
+export { createHash } from './shell-node-crypto.js';
+
+let fflatePromise = null;
+async function getFflate() {
+  if (!fflatePromise) fflatePromise = import('https://esm.sh/fflate@0.8.2/es2022/fflate.mjs').then(m => m.gzipSync ? m : (m.default && m.default.gzipSync ? m.default : m));
+  return fflatePromise;
+}
+let fflateSync = null;
+export async function preloadFflate() { fflateSync = await getFflate(); return fflateSync; }
+
+export function createZlib(Buf) {
+  const need = () => { if (!fflateSync) throw new Error('zlib sync: preloadFflate() must run before sync zlib calls (auto-preloaded on node entry)'); return fflateSync; };
+  return {
+    gzipSync: b => Buf.from(need().gzipSync(b instanceof Uint8Array ? b : new TextEncoder().encode(String(b)))),
+    gunzipSync: b => Buf.from(need().gunzipSync(b)),
+    deflateSync: b => Buf.from(need().deflateSync(b instanceof Uint8Array ? b : new TextEncoder().encode(String(b)))),
+    inflateSync: b => Buf.from(need().inflateSync(b)),
+    deflateRawSync: b => Buf.from(need().deflateSync(b, { raw: true }) || need().deflateSync(b)),
+    inflateRawSync: b => Buf.from(need().inflateSync(b, { raw: true }) || need().inflateSync(b)),
+    gzip: async (buf, cb) => { try { const p = await getFflate(); const out = Buf.from(p.gzipSync(buf instanceof Uint8Array ? buf : new TextEncoder().encode(String(buf)))); if (cb) cb(null, out); return out; } catch (e) { if (cb) cb(e); else throw e; } },
+    gunzip: async (buf, cb) => { try { const p = await getFflate(); const out = Buf.from(p.gunzipSync(buf)); if (cb) cb(null, out); return out; } catch (e) { if (cb) cb(e); else throw e; } },
+    deflate: async (buf, cb) => { const p = await getFflate(); const out = Buf.from(p.deflateSync(buf instanceof Uint8Array ? buf : new TextEncoder().encode(String(buf)))); if (cb) cb(null, out); return out; },
+    inflate: async (buf, cb) => { const p = await getFflate(); const out = Buf.from(p.inflateSync(buf)); if (cb) cb(null, out); return out; },
+    createGzip: () => ({ pipe: () => {}, on: () => {}, write: () => {}, end: () => {} }),
+    createGunzip: () => ({ pipe: () => {}, on: () => {}, write: () => {}, end: () => {} }),
+    constants: { Z_NO_FLUSH: 0, Z_PARTIAL_FLUSH: 1, Z_SYNC_FLUSH: 2, Z_FULL_FLUSH: 3, Z_FINISH: 4, Z_BLOCK: 5, Z_TREES: 6, Z_OK: 0, Z_STREAM_END: 1 },
+  };
+}

package/docs/shell-node-streams.js

@@ -0,0 +1,66 @@
+function makeEmitter(){
+  const h={};
+  return {
+    on(e,f){(h[e]=h[e]||[]).push(f);return this;},
+    once(e,f){const w=(...a)=>{this.off(e,w);f(...a);};return this.on(e,w);},
+    off(e,f){h[e]=(h[e]||[]).filter(x=>x!==f);return this;},
+    removeListener(e,f){return this.off(e,f);},
+    removeAllListeners(e){if(e)delete h[e];else for(const k of Object.keys(h))delete h[k];return this;},
+    emit(e,...a){for(const f of(h[e]||[]).slice())f(...a);return(h[e]||[]).length>0;},
+    listenerCount(e){return(h[e]||[]).length;},
+    _h:h,
+  };
+}
+
+class Readable{
+  constructor(opts={}){
+    Object.assign(this,makeEmitter());
+    this._q=[];this._ended=false;this._flowing=null;this._paused=false;this._destroyed=false;
+    this.readable=true;this.readableHighWaterMark=opts.highWaterMark??16384;this.readableEnded=false;this.readableObjectMode=!!opts.objectMode;
+    this._read=opts.read||(()=>{});this._encoding=null;
+  }
+  push(chunk){if(chunk===null){this._ended=true;queueMicrotask(()=>this._drain());return false;}this._q.push(chunk);queueMicrotask(()=>this._drain());return this._q.length<this.readableHighWaterMark;}
+  read(n){if(!this._q.length)return null;return n?this._q.shift():this._q.shift();}
+  _drain(){if(this._paused||this._destroyed)return;while(this._q.length){const c=this._q.shift();const data=this._encoding&&c instanceof Uint8Array?new TextDecoder(this._encoding).decode(c):c;this.emit('data',data);}if(this._ended&&!this.readableEnded){this.readableEnded=true;this.emit('end');}}
+  pause(){this._paused=true;return this;}
+  resume(){this._paused=false;queueMicrotask(()=>this._drain());return this;}
+  pipe(dest){this.on('data',c=>{if(dest.write(c)===false)this.pause();});this.on('end',()=>dest.end?.());dest.on?.('drain',()=>this.resume());return dest;}
+  unpipe(){return this;}
+  setEncoding(enc){this._encoding=enc;return this;}
+  destroy(e){this._destroyed=true;if(e)this.emit('error',e);this.emit('close');return this;}
+  [Symbol.asyncIterator](){const self=this;return{async next(){if(self._q.length)return{value:self._q.shift(),done:false};if(self._ended)return{value:undefined,done:true};return new Promise(r=>{const onData=c=>{self.off('data',onData);self.off('end',onEnd);r({value:c,done:false});};const onEnd=()=>{self.off('data',onData);r({value:undefined,done:true});};self.on('data',onData);self.once('end',onEnd);});}};}
+}
+
+class Writable{
+  constructor(opts={}){
+    Object.assign(this,makeEmitter());
+    this._write=opts.write||((c,e,cb)=>cb());this.writable=true;this.writableEnded=false;this.writableFinished=false;this.writableHighWaterMark=opts.highWaterMark??16384;this._pending=0;
+  }
+  write(chunk,enc,cb){if(typeof enc==='function'){cb=enc;enc=null;}if(this.writableEnded){const e=Object.assign(new Error('write after end'),{code:'ERR_STREAM_WRITE_AFTER_END'});queueMicrotask(()=>cb?.(e));return false;}this._pending++;this._write(chunk,enc,err=>{this._pending--;cb?.(err);if(this._pending===0)this.emit('drain');});return this._pending<this.writableHighWaterMark;}
+  end(chunk,enc,cb){if(chunk!=null)this.write(chunk,enc);this.writableEnded=true;queueMicrotask(()=>{this.writableFinished=true;this.emit('finish');this.emit('close');cb?.();});return this;}
+  destroy(e){if(e)this.emit('error',e);this.emit('close');return this;}
+}
+
+class Duplex extends Readable{constructor(opts={}){super(opts);Object.assign(this,new Writable(opts));this._write=opts.write||((c,e,cb)=>cb());}write(...a){return Writable.prototype.write.call(this,...a);}end(...a){return Writable.prototype.end.call(this,...a);}}
+
+class Transform extends Duplex{
+  constructor(opts={}){super(opts);this._transform=opts.transform||((c,e,cb)=>cb(null,c));this._flush=opts.flush||(cb=>cb());this._write=(c,e,cb)=>{this._transform(c,e,(err,out)=>{if(err)return cb(err);if(out!=null)this.push(out);cb();});};const origEnd=this.end.bind(this);this.end=(...a)=>{this._flush((err,out)=>{if(out!=null)this.push(out);this.push(null);});return origEnd(...a);};}
+}
+
+class PassThrough extends Transform{constructor(opts){super({...opts,transform:(c,e,cb)=>cb(null,c)});}}
+
+function pipeline(...args){const cb=typeof args[args.length-1]==='function'?args.pop():null;const streams=args;let done=false;const fin=e=>{if(done)return;done=true;cb?.(e);};for(let i=0;i<streams.length-1;i++){const src=streams[i],dst=streams[i+1];src.on('error',fin);src.pipe(dst);}streams[streams.length-1].on('finish',()=>fin(null));streams[streams.length-1].on('error',fin);return streams[streams.length-1];}
+
+function finished(stream,cb){const onFin=()=>cb();const onErr=e=>cb(e);stream.on?.('finish',onFin);stream.on?.('end',onFin);stream.on?.('error',onErr);return()=>{stream.off?.('finish',onFin);stream.off?.('end',onFin);stream.off?.('error',onErr);};}
+
+export function makeStream(){
+  const mod={Readable,Writable,Duplex,Transform,PassThrough,pipeline,finished,promises:{pipeline:(...a)=>new Promise((res,rej)=>pipeline(...a,e=>e?rej(e):res())),finished:s=>new Promise((res,rej)=>finished(s,e=>e?rej(e):res()))}};
+  Readable.from=iter=>{const r=new Readable();(async()=>{try{for await(const c of iter)r.push(c);r.push(null);}catch(e){r.destroy(e);}})();return r;};
+  return mod;
+}
+
+export function extendFsStreams(fs,Buf){
+  fs.createReadStream=(path,opts={})=>{const r=new Readable();queueMicrotask(()=>{try{const data=fs.readFileSync(path);const buf=typeof data==='string'?Buf.from(data):data;const start=opts.start||0;const end=opts.end??buf.length;r.push(buf.slice(start,end));r.push(null);}catch(e){r.destroy(e);}});return r;};
+  fs.createWriteStream=(path,opts={})=>{const chunks=[];const w=new Writable({write:(c,e,cb)=>{chunks.push(typeof c==='string'?Buf.from(c):c);cb();}});w.on('finish',()=>{try{fs.writeFileSync(path,Buf.concat(chunks));}catch(e){w.emit('error',e);}});return w;};
+  return fs;
+}

package/docs/shell-node-tar.js

@@ -0,0 +1,47 @@
+const BLOCK=512;
+const readStr=(buf,o,len)=>{let e=o;while(e<o+len&&buf[e]!==0)e++;return new TextDecoder().decode(buf.slice(o,e));};
+const readOctal=(buf,o,len)=>{const s=readStr(buf,o,len).trim();return s?parseInt(s,8):0;};
+
+export function untar(data){
+  const buf=data instanceof Uint8Array?data:new Uint8Array(data);
+  const entries=[];let off=0;
+  while(off+BLOCK<=buf.length){
+    if(buf[off]===0&&buf[off+BLOCK-1]===0){off+=BLOCK;continue;}
+    const name=readStr(buf,off,100);
+    if(!name)break;
+    const mode=readOctal(buf,off+100,8);
+    const size=readOctal(buf,off+124,12);
+    const mtime=readOctal(buf,off+136,12);
+    const type=String.fromCharCode(buf[off+156]||0x30);
+    const prefix=readStr(buf,off+345,155);
+    const fullName=prefix?prefix+'/'+name:name;
+    const dataStart=off+BLOCK;
+    const dataEnd=dataStart+size;
+    const body=type==='0'||type==='\0'?buf.slice(dataStart,dataEnd):null;
+    entries.push({name:fullName,mode,size,mtime,type,data:body});
+    const padded=Math.ceil(size/BLOCK)*BLOCK;
+    off=dataStart+padded;
+  }
+  return entries;
+}
+
+export function makeTar(fs,fflate,Buf){
+  return{
+    async extract(data,dest='/'){
+      let bytes=data instanceof Uint8Array?data:new Uint8Array(data);
+      if(bytes[0]===0x1f&&bytes[1]===0x8b){bytes=fflate?.gunzipSync?fflate.gunzipSync(bytes):bytes;}
+      const entries=untar(bytes);
+      const out=[];
+      for(const e of entries){
+        if(!e.data&&e.type!=='5')continue;
+        const target=(dest.replace(/\/$/,'')+'/'+e.name).replace(/^\/+/,'/');
+        if(e.type==='5'){try{fs.mkdirSync(target,{recursive:true});}catch{}}
+        else{const parts=target.split('/');for(let i=1;i<parts.length;i++){const d=parts.slice(0,i).join('/');if(d&&!fs.existsSync(d)){try{fs.mkdirSync(d,{recursive:true});}catch{}}}fs.writeFileSync(target,Buf.from(e.data));}
+        out.push(target);
+      }
+      return out;
+    },
+    async list(data){let bytes=data instanceof Uint8Array?data:new Uint8Array(data);if(bytes[0]===0x1f&&bytes[1]===0x8b)bytes=fflate?.gunzipSync?fflate.gunzipSync(bytes):bytes;return untar(bytes).map(e=>e.name);},
+    untar,
+  };
+}

package/docs/shell-node-testrunner.js

@@ -0,0 +1,35 @@
+export function makeTestRunner(term){
+  const suites=[];let current=null;const results={pass:0,fail:0,skip:0,failures:[]};
+  const write=term?(s=>term.write(s)):(s=>console.log(s.replace(/\r\n/g,'')));
+  const color=(c,s)=>`\x1b[${c}m${s}\x1b[0m`;
+  async function runOne(name,fn,parentPath=''){
+    const path=(parentPath?parentPath+' > ':'')+name;
+    if(!fn){results.skip++;write(color(33,'  - '+path+' (skip)')+'\r\n');return;}
+    const t0=performance.now();
+    try{await fn(tctx(name,path));results.pass++;write(color(32,'  ✓ '+path)+` ${(performance.now()-t0).toFixed(1)}ms\r\n`);}
+    catch(e){results.fail++;results.failures.push({path,error:e});write(color(31,'  ✗ '+path+' — '+e.message)+'\r\n');}
+  }
+  function tctx(name,path){return{name,fullName:path,diagnostic(m){write(color(90,'    # '+m)+'\r\n');},skip(){throw Object.assign(new Error('skip'),{__skip:true});},todo(){throw Object.assign(new Error('todo'),{__todo:true});},signal:new AbortController().signal,plan(n){}};}
+  function test(name,optsOrFn,maybeFn){const fn=typeof optsOrFn==='function'?optsOrFn:maybeFn;const opts=typeof optsOrFn==='object'?optsOrFn:{};if(opts.skip)return runOne(name,null);if(opts.only){}if(current){current.tests.push({name,fn});return Promise.resolve();}return runOne(name,fn);}
+  function describe(name,fn){const prev=current;current={name,tests:[],parentPath:prev?prev.fullPath:'',fullPath:(prev?prev.fullPath+' > ':'')+name};try{fn(current);}finally{const c=current;current=prev;return(async()=>{for(const t of c.tests)await runOne(t.name,t.fn,c.fullPath);})();}}
+  const mock={
+    fn(impl){const calls=[];const mk=function(...a){calls.push({arguments:a,result:undefined,error:undefined,target:this});try{const r=impl?impl.apply(this,a):undefined;calls[calls.length-1].result=r;return r;}catch(e){calls[calls.length-1].error=e;throw e;}};mk.mock={calls,callCount(){return calls.length;},resetCalls(){calls.length=0;},restore(){}};return mk;},
+    method(obj,key,impl){const orig=obj[key];const m=mock.fn(impl||orig);obj[key]=m;m.mock.restore=()=>{obj[key]=orig;};return m;},
+    timers:{enable(){},reset(){},runAll(){},tick(){},restore(){}},
+  };
+  const api={test,describe,it:test,before:fn=>fn?.(),after:fn=>fn?.(),beforeEach:()=>{},afterEach:()=>{},mock,run(){},results,
+    async summarize(){write('\r\n'+color(1,`# tests ${results.pass+results.fail+results.skip}`)+'\r\n');write(color(32,`# pass ${results.pass}`)+'\r\n');write(color(31,`# fail ${results.fail}`)+'\r\n');write(color(33,`# skip ${results.skip}`)+'\r\n');return results.fail===0;},
+  };
+  return api;
+}
+
+export function makeTapReporter(term){
+  const w=term?(s=>term.write(s)):(s=>console.log(s));
+  let n=0;
+  return{
+    ok(name){w(`ok ${++n} - ${name}\r\n`);},
+    notOk(name,msg){w(`not ok ${++n} - ${name}\r\n  ---\r\n  error: ${msg}\r\n  ...\r\n`);},
+    plan(total){w(`1..${total}\r\n`);},
+    comment(m){w(`# ${m}\r\n`);},
+  };
+}

package/docs/shell-node-util-extras.js

@@ -0,0 +1,66 @@
+const ANSI_RE=/\x1b\[[0-9;]*[a-zA-Z]/g;
+const STYLE_CODES={reset:0,bold:1,dim:2,italic:3,underline:4,inverse:7,hidden:8,strikethrough:9,black:30,red:31,green:32,yellow:33,blue:34,magenta:35,cyan:36,white:37,gray:90,bgBlack:40,bgRed:41,bgGreen:42,bgYellow:43,bgBlue:44,bgMagenta:45,bgCyan:46,bgWhite:47};
+
+export function styleText(styles,text){
+  const arr=Array.isArray(styles)?styles:[styles];
+  const codes=arr.map(s=>STYLE_CODES[s]).filter(c=>c!=null);
+  if(!codes.length)return text;
+  return `\x1b[${codes.join(';')}m${text}\x1b[0m`;
+}
+
+export function stripVTControlCharacters(s){return String(s).replace(ANSI_RE,'');}
+
+export function getCallSites(frames=10){
+  const e=new Error();const lines=(e.stack||'').split('\n').slice(2,2+frames);
+  return lines.map(l=>{const m=l.match(/at\s+(?:(.+?)\s+\()?(.+?):(\d+):(\d+)\)?/);return{functionName:m?.[1]||'<anonymous>',scriptName:m?.[2]||'',lineNumber:m?+m[3]:0,column:m?+m[4]:0,scriptId:'0'};});
+}
+
+export class MIMEType{
+  constructor(input){
+    const [essence,...paramParts]=String(input).split(';');
+    const [type,subtype]=essence.trim().split('/');
+    if(!type||!subtype)throw new TypeError('Invalid MIME: '+input);
+    this._type=type.toLowerCase();this._sub=subtype.toLowerCase();
+    this._params=new MIMEParams();
+    for(const p of paramParts){const [k,v]=p.split('=');if(k&&v)this._params.set(k.trim().toLowerCase(),v.trim().replace(/^["']|["']$/g,''));}
+  }
+  get type(){return this._type;}set type(v){this._type=String(v).toLowerCase();}
+  get subtype(){return this._sub;}set subtype(v){this._sub=String(v).toLowerCase();}
+  get essence(){return `${this._type}/${this._sub}`;}
+  get params(){return this._params;}
+  toString(){const p=[...this._params].map(([k,v])=>`${k}=${v}`).join(';');return this.essence+(p?';'+p:'');}
+}
+
+export class MIMEParams{
+  constructor(){this._m=new Map();}
+  get(k){return this._m.get(k);}
+  set(k,v){this._m.set(String(k).toLowerCase(),String(v));return this;}
+  delete(k){return this._m.delete(k);}
+  has(k){return this._m.has(k);}
+  *entries(){yield*this._m.entries();}
+  *keys(){yield*this._m.keys();}
+  *values(){yield*this._m.values();}
+  [Symbol.iterator](){return this._m[Symbol.iterator]();}
+}
+
+export function makeConsoleExtras(origConsole,term){
+  const write=term?(s=>term.write(s)):(s=>origConsole.log(s));
+  const timers=new Map();const counters=new Map();let groupDepth=0;const ind=()=>'  '.repeat(groupDepth);
+  return{
+    table(data,columns){if(!data||typeof data!=='object')return origConsole.log(data);const rows=Array.isArray(data)?data:Object.entries(data).map(([k,v])=>({'(index)':k,...(typeof v==='object'?v:{Values:v})}));if(!rows.length)return;const cols=columns||[...new Set(rows.flatMap(r=>Object.keys(r)))];const w=cols.map(c=>Math.max(c.length,...rows.map(r=>String(r[c]??'').length)));const line=(cells,pad)=>'│ '+cells.map((c,i)=>String(c??'').padEnd(w[i]))+' │\r\n';const sep=s=>s+cols.map((_,i)=>'─'.repeat(w[i]+2)).join(s==='├'?'┼':'─')+(s==='├'?'┤':'╯')+'\r\n';write('╭'+cols.map((_,i)=>'─'.repeat(w[i]+2)).join('─')+'╮\r\n');write('│ '+cols.map((c,i)=>c.padEnd(w[i])).join(' │ ')+' │\r\n');write('├'+cols.map((_,i)=>'─'.repeat(w[i]+2)).join('┼')+'┤\r\n');for(const r of rows)write('│ '+cols.map((c,i)=>String(r[c]??'').padEnd(w[i])).join(' │ ')+' │\r\n');write('╰'+cols.map((_,i)=>'─'.repeat(w[i]+2)).join('─')+'╯\r\n');},
+    group(label){if(label)write(ind()+label+'\r\n');groupDepth++;},
+    groupCollapsed(label){this.group(label);},
+    groupEnd(){groupDepth=Math.max(0,groupDepth-1);},
+    time(label='default'){timers.set(label,performance.now());},
+    timeEnd(label='default'){const t=timers.get(label);if(t==null)return;timers.delete(label);write(`${label}: ${(performance.now()-t).toFixed(3)}ms\r\n`);},
+    timeLog(label='default',...rest){const t=timers.get(label);if(t==null)return;write(`${label}: ${(performance.now()-t).toFixed(3)}ms ${rest.join(' ')}\r\n`);},
+    count(label='default'){const n=(counters.get(label)||0)+1;counters.set(label,n);write(`${label}: ${n}\r\n`);},
+    countReset(label='default'){counters.set(label,0);},
+    dir(v){write(JSON.stringify(v,null,2)+'\r\n');},
+    dirxml(v){this.dir(v);},
+    trace(...a){write('Trace: '+a.join(' ')+'\r\n'+new Error().stack+'\r\n');},
+    assert(cond,...msg){if(!cond)write('Assertion failed: '+msg.join(' ')+'\r\n');},
+    clear(){write('\x1b[2J\x1b[H');},
+    profile(){},profileEnd(){},timeStamp(){},
+  };
+}