thebird 1.2.79 → 1.2.80

package/docs/shell-exec.js

@@ -0,0 +1,85 @@
+import { registerStream, readStream } from './shell-procsub.js';
+import { tokenize, globToRe } from './shell-parser.js';
+import { fullExpand, expandBraces, expandTilde } from './shell-expand.js';
+import { resolvePath } from './shell-builtins.js';
+import { NODE_VERSION } from './shell-node-modules.js';
+
+export function makeExpander(ctx, captureRun, parseRedirect) {
+  const toKey = p => p.replace(/^\//, '');
+  const snap = () => window.__debug.idbSnapshot || {};
+
+  function replaceProcSub(token) {
+    let out = ''; let i = 0;
+    while (i < token.length) {
+      if ((token[i] === '<' || token[i] === '>') && token[i + 1] === '(') {
+        let depth = 1; let j = i + 2;
+        while (j < token.length && depth > 0) { if (token[j] === '(') depth++; else if (token[j] === ')') depth--; if (depth) j++; }
+        if (depth === 0) { out += registerStream(captureRun(token.slice(i + 2, j))); i = j + 1; continue; }
+      }
+      out += token[i++];
+    }
+    return out;
+  }
+
+  function expandGlob(token) {
+    if (!token.includes('*') && !token.includes('?') && !token.includes('[')) return [token];
+    const prefix = toKey(resolvePath(ctx.cwd, ''));
+    const keys = Object.keys(snap()).map(k => prefix && k.startsWith(prefix + '/') ? k.slice(prefix.length + 1) : k);
+    const re = globToRe(token);
+    const matches = keys.filter(k => re.test(k));
+    return matches.length ? matches.sort() : [token];
+  }
+
+  function expandTokens(tokens) {
+    return tokens.flatMap(t => {
+      const procsub = t.includes('<(') || t.includes('>(') ? replaceProcSub(t) : t;
+      const tilde = expandTilde(procsub, ctx.env);
+      const braces = expandBraces(tilde);
+      return braces.flatMap(b => expandGlob(fullExpand(b, ctx.env, ctx.lastExitCode, ctx.argv, captureRun, ctx.arrays)));
+    });
+  }
+  return { expandTokens, expandGlob, replaceProcSub };
+}
+
+export function makeCaptureRun(ctx, BUILTINS, actor, parseRedirect, expandTokens) {
+  return function captureRun(line) {
+    const raw = tokenize(line); if (!raw.length) return '';
+    let out = ''; const orig = ctx.term.write.bind(ctx.term); ctx.term.write = s => { out += s; };
+    try { const [cmd, ...args] = parseRedirect(expandTokens(raw)).args; BUILTINS[cmd]?.(args, actor); } finally { ctx.term.write = orig; }
+    return out.replace(/\r\n/g, '\n').replace(/\r/g, '\n').trim();
+  };
+}
+
+const NODE_HELP = 'Usage: node [options] [script.js] [arguments]\r\n  -v, --version   print Node.js version\r\n  -e, --eval      evaluate script\r\n  -p, --print     evaluate and print result\r\n  -h, --help      print this help\r\n';
+
+export function makeNodeRunner(ctx, actor) {
+  const toKey = p => p.replace(/^\//, '');
+  const snap = () => window.__debug.idbSnapshot || {};
+  return async function runNode(args, stdinBuf) {
+    const term = ctx.term;
+    if (!args.length) { actor.send({ type: 'ENTER_REPL' }); term.write('Welcome to Node.js ' + NODE_VERSION + '.\r\nType ".help" for more information.\r\n> '); return; }
+    const a0 = args[0];
+    if (a0 === '-v' || a0 === '--version') { term.write(NODE_VERSION + '\r\n'); return; }
+    if (a0 === '-h' || a0 === '--help') { term.write(NODE_HELP); return; }
+    if (a0 === '-e' || a0 === '--eval') { await ctx.nodeEval(args.slice(1).join(' '), null, [], stdinBuf); return; }
+    if (a0 === '-p' || a0 === '--print') { await ctx.nodeEval('process.stdout.write(String(' + args.slice(1).join(' ') + ') + "\\n")', null, [], stdinBuf); return; }
+    const code = snap()[toKey(resolvePath(ctx.cwd, a0))];
+    if (code == null) { term.write('\x1b[31mnode: ' + a0 + ': No such file or directory\x1b[0m\r\n'); ctx.lastExitCode = 1; return; }
+    actor.send({ type: 'NODE_START' }); ctx.argv = args;
+    try { await ctx.nodeEval(code, a0, args.slice(1), stdinBuf); } finally { ctx.argv = []; }
+  };
+}
+
+export function makeNpmResultRunner(ctx, run) {
+  return async function runNpmResult(r) {
+    if (!r) return;
+    if (r.runInShell) { await run(r.runInShell); return; }
+    if (!r.npmChain) return;
+    for (const step of r.npmChain) {
+      ctx.term.write('\r\n> ' + r.pkgName + '@' + r.pkgVersion + ' ' + step.name + '\r\n> ' + step.cmd + '\r\n\r\n');
+      ctx.env.npm_lifecycle_event = step.name;
+      await run(step.cmd);
+      if (ctx.lastExitCode !== 0) return;
+    }
+  };
+}

package/docs/shell-expand.js

@@ -0,0 +1,164 @@
+export function expandParam(name, env, argv, lastExit, arrays) {
+  if (name === '?') return String(lastExit ?? 0);
+  if (name === '!') return env['!'] || '';
+  if (name === '$') return env.$ || '0';
+  if (name === '#') return String((argv || []).length > 0 ? (argv || []).length - 1 : 0);
+  if (name === '@' || name === '*') return (argv || []).slice(1).join(' ');
+  if (name === '0') return (argv || [])[0] || '';
+  if (/^[1-9]$/.test(name)) return (argv || [])[parseInt(name)] || '';
+  const arrM = name.match(/^([A-Za-z_][A-Za-z0-9_]*)\[(.+?)\]$/);
+  if (arrM && arrays) {
+    const a = arrays[arrM[1]];
+    if (a == null) return '';
+    if (arrM[2] === '@' || arrM[2] === '*') return Array.isArray(a) ? a.join(' ') : Object.values(a).join(' ');
+    if (Array.isArray(a)) return a[parseInt(arrM[2], 10)] || '';
+    return a[arrM[2]] || '';
+  }
+  const lenArrM = name.match(/^#([A-Za-z_][A-Za-z0-9_]*)\[@\]$/);
+  if (lenArrM && arrays) { const a = arrays[lenArrM[1]] || []; return String(Array.isArray(a) ? a.length : Object.keys(a).length); }
+  return env[name] ?? '';
+}
+
+export function expandParamOp(expr, env, argv, lastExit, arrays) {
+  if (expr.startsWith('!')) {
+    const prefM = expr.match(/^!([A-Za-z_]\w*)([@*])$/);
+    if (prefM) return Object.keys(env).filter(k => k.startsWith(prefM[1])).join(' ');
+    const keysM = expr.match(/^!([A-Za-z_]\w*)\[[@*]\]$/);
+    if (keysM && arrays) { const a = arrays[keysM[1]] || []; return Array.isArray(a) ? a.map((_, i) => i).join(' ') : Object.keys(a).join(' '); }
+    const indM = expr.match(/^!([A-Za-z_]\w*)$/);
+    if (indM) { const t = env[indM[1]]; return t ? expandParam(t, env, argv, lastExit, arrays) : ''; }
+  }
+  const caseM = expr.match(/^([A-Za-z_][A-Za-z0-9_]*|@)(\^\^|,,|\^|,)(.*)$/s);
+  if (caseM) {
+    const v = expandParam(caseM[1], env, argv, lastExit, arrays);
+    const op = caseM[2];
+    if (op === '^^') return v.toUpperCase();
+    if (op === ',,') return v.toLowerCase();
+    if (op === '^') return v.charAt(0).toUpperCase() + v.slice(1);
+    if (op === ',') return v.charAt(0).toLowerCase() + v.slice(1);
+  }
+  const qM = expr.match(/^([A-Za-z_][A-Za-z0-9_]*|@)@([QEP])$/);
+  if (qM) {
+    const v = expandParam(qM[1], env, argv, lastExit, arrays);
+    if (qM[2] === 'Q') return "'" + v.replace(/'/g, "'\\''") + "'";
+    if (qM[2] === 'E') return v.replace(/\\n/g, '\n').replace(/\\t/g, '\t');
+    if (qM[2] === 'P') return v;
+  }
+  const lenArrM = expr.match(/^#([A-Za-z_]\w*)\[[@*]\]$/);
+  if (lenArrM) { const a = (arrays || {})[lenArrM[1]] || []; return String(Array.isArray(a) ? a.length : Object.keys(a).length); }
+  const lenM = expr.match(/^#(.+)$/);
+  if (lenM) return String(expandParam(lenM[1], env, argv, lastExit, arrays).length);
+  const sliceM = expr.match(/^([^:]+):(\d+)(?::(\d+))?$/);
+  if (sliceM) { const v = expandParam(sliceM[1], env, argv, lastExit, arrays); const s = +sliceM[2]; return sliceM[3] !== undefined ? v.slice(s, s + (+sliceM[3])) : v.slice(s); }
+  const defM = expr.match(/^([A-Za-z_][A-Za-z0-9_]*|\?|#|@|[0-9])(:-|:=|:\?|:\+|-|=|\+)(.*)$/s);
+  if (defM) {
+    const [, name, op, def] = defM;
+    const v = expandParam(name, env, argv, lastExit, arrays);
+    const defined = v !== '' && v != null;
+    if (op === ':-' || op === '-') return defined ? v : def;
+    if (op === ':=' || op === '=') { if (!defined) env[name] = def; return defined ? v : def; }
+    if (op === ':?' || op === '?') { if (!defined) throw new Error(name + ': ' + (def || 'parameter null')); return v; }
+    if (op === ':+' || op === '+') return defined ? def : '';
+  }
+  const sufM = expr.match(/^([A-Za-z_][A-Za-z0-9_]*|@|#)(%%?|##?)(.+)$/s);
+  if (sufM) {
+    const [, name, op, pat] = sufM;
+    const v = expandParam(name, env, argv, lastExit, arrays);
+    const bare = globReLine(pat).replace(/^\^|\$$/g, '');
+    if (op === '#') { const m = v.match(new RegExp('^' + bare)); return m ? v.slice(m[0].length) : v; }
+    if (op === '##') { const m = v.match(new RegExp('^' + bare.replace(/\.\*/g, '.*?') + '.*')); return m ? '' : v; }
+    if (op === '%') { const m = v.match(new RegExp(bare + '$')); return m ? v.slice(0, -m[0].length) : v; }
+    if (op === '%%') { const m = v.match(new RegExp('^.*' + bare + '$')); return m ? '' : v; }
+  }
+  const subM = expr.match(/^([A-Za-z_][A-Za-z0-9_]*|@)\/(\/?)(.+?)\/(.*)$/s);
+  if (subM) {
+    const [, name, all, pat, rep] = subM;
+    const v = expandParam(name, env, argv, lastExit, arrays);
+    return v.replace(new RegExp(globReLine(pat).replace(/^\^|\$$/g, ''), all ? 'g' : ''), rep);
+  }
+  return expandParam(expr, env, argv, lastExit, arrays);
+}
+
+function globReLine(pat) { return '^' + pat.replace(/[-[\]{}()+.,\\^$|#]/g, (c) => (c === '*' || c === '?') ? c : '\\' + c).replace(/\*/g, '.*').replace(/\?/g, '.') + '$'; }
+
+export function evalArith(expr, env) {
+  const src = expr.replace(/\b([A-Za-z_][A-Za-z0-9_]*)\b/g, (_, n) => String(parseInt(env[n], 10) || 0));
+  if (!/^[-+*/%()<>=!&|\s\d?:]+$/.test(src)) return 0;
+  try { return Function('"use strict"; return (' + src + ')')() | 0; } catch { return 0; }
+}
+
+export function expandBraces(token) {
+  const listM = token.match(/^(.*?)\{([^{}]*,[^{}]*)\}(.*)$/s);
+  if (listM) {
+    const [, pre, list, post] = listM;
+    return list.split(',').flatMap(p => expandBraces(pre + p + post));
+  }
+  const rangeM = token.match(/^(.*?)\{(-?\d+)\.\.(-?\d+)(?:\.\.(-?\d+))?\}(.*)$/s);
+  if (rangeM) {
+    const [, pre, a, b, step, post] = rangeM;
+    const s = step ? +step : ((+a) <= (+b) ? 1 : -1);
+    const out = [];
+    for (let i = +a; s > 0 ? i <= +b : i >= +b; i += s) out.push(i);
+    return out.flatMap(i => expandBraces(pre + i + post));
+  }
+  return [token];
+}
+
+export function expandTilde(token, env) {
+  if (token === '~') return env.HOME || '/';
+  if (token.startsWith('~/')) return (env.HOME || '') + token.slice(1);
+  const m = token.match(/^~([A-Za-z_][A-Za-z0-9_]*)(\/.*)?$/);
+  if (m) return '/home/' + m[1] + (m[2] || '');
+  return token;
+}
+
+export function fullExpand(token, env, lastExit, argv, runCap, arrays) {
+  let out = '';
+  let i = 0;
+  while (i < token.length) {
+    if (token[i] === '`') {
+      const end = token.indexOf('`', i + 1);
+      if (end < 0) { out += token.slice(i); break; }
+      out += runCap ? runCap(token.slice(i + 1, end)) : '';
+      i = end + 1; continue;
+    }
+    if (token[i] === '$' && token[i + 1] === '(' && token[i + 2] === '(') {
+      const close = token.indexOf('))', i + 3);
+      if (close < 0) { out += token[i++]; continue; }
+      out += String(evalArith(token.slice(i + 3, close), env));
+      i = close + 2; continue;
+    }
+    if (token[i] === '$' && token[i + 1] === '(') {
+      const end = findMatch(token, i + 1, '(', ')');
+      if (end < 0) { out += token[i++]; continue; }
+      out += runCap ? runCap(token.slice(i + 2, end)) : '';
+      i = end + 1; continue;
+    }
+    if (token[i] === '$' && token[i + 1] === '{') {
+      const end = token.indexOf('}', i + 2);
+      if (end < 0) { out += token[i++]; continue; }
+      out += expandParamOp(token.slice(i + 2, end), env, argv, lastExit, arrays);
+      i = end + 1; continue;
+    }
+    if (token[i] === '$') {
+      const m = token.slice(i + 1).match(/^(\?|!|#|@|\*|[0-9]|[A-Za-z_][A-Za-z0-9_]*)/);
+      if (m) { out += expandParam(m[1], env, argv, lastExit, arrays); i += 1 + m[1].length; continue; }
+    }
+    out += token[i++];
+  }
+  return out;
+}
+
+function findMatch(s, start, open, close) {
+  let depth = 0; let inSingle = false, inDouble = false;
+  for (let i = start; i < s.length; i++) {
+    const c = s[i];
+    if (c === "'" && !inDouble) inSingle = !inSingle;
+    else if (c === '"' && !inSingle) inDouble = !inDouble;
+    else if (!inSingle && !inDouble) {
+      if (c === open) depth++;
+      else if (c === close) { depth--; if (depth === 0) return i; }
+    }
+  }
+  return -1;
+}

package/docs/shell-fd.js

@@ -0,0 +1,86 @@
+export function createFdTable(ctx) {
+  const table = { 0: { kind: 'stdin', data: '' }, 1: { kind: 'stdout' }, 2: { kind: 'stderr' } };
+  ctx.fds = table;
+
+  function open(fd, source, mode) {
+    const n = parseInt(fd, 10);
+    if (isNaN(n)) throw new Error('fd: invalid: ' + fd);
+    table[n] = { kind: 'file', path: source, mode: mode || 'r', buf: '' };
+    return n;
+  }
+
+  function close(fd) {
+    const n = parseInt(fd, 10);
+    delete table[n];
+  }
+
+  function dup2(src, dst) {
+    const s = parseInt(src, 10);
+    const d = parseInt(dst, 10);
+    if (!table[s]) throw new Error('fd: ' + src + ': bad descriptor');
+    table[d] = { ...table[s], duped: s };
+  }
+
+  function readFd(fd) {
+    const n = parseInt(fd, 10);
+    const slot = table[n];
+    if (!slot) throw new Error('fd ' + fd + ' not open');
+    if (slot.kind === 'stdin') return slot.data || '';
+    if (slot.kind === 'file') {
+      const snap = window.__debug?.idbSnapshot || {};
+      return snap[slot.path.replace(/^\//, '')] || '';
+    }
+    return slot.buf || '';
+  }
+
+  function writeFd(fd, data) {
+    const n = parseInt(fd, 10);
+    const slot = table[n];
+    if (!slot) throw new Error('fd ' + fd + ' not open');
+    if (slot.kind === 'stdout' || n === 1) ctx.term.write(data.replace(/\n/g, '\r\n'));
+    else if (slot.kind === 'stderr' || n === 2) ctx.term.write('\x1b[31m' + data.replace(/\n/g, '\r\n') + '\x1b[0m');
+    else if (slot.kind === 'file') {
+      const snap = window.__debug?.idbSnapshot || (window.__debug.idbSnapshot = {});
+      const k = slot.path.replace(/^\//, '');
+      snap[k] = slot.mode === 'a' ? (snap[k] || '') + data : data;
+      window.__debug?.idbPersist?.();
+    } else { slot.buf = (slot.buf || '') + data; }
+  }
+
+  return { table, open, close, dup2, readFd, writeFd };
+}
+
+export function parseFdRedirects(tokens) {
+  const out = { args: [], redirs: [] };
+  for (let i = 0; i < tokens.length; i++) {
+    const t = tokens[i];
+    const m = t.match(/^(\d+)?(>>|>|<|>&|<&)(\d+)?$/);
+    if (m) {
+      const from = m[1] != null ? +m[1] : (m[2].includes('<') ? 0 : 1);
+      const op = m[2];
+      const toNum = m[3] != null ? +m[3] : null;
+      if (op === '>&' || op === '<&') { out.redirs.push({ kind: 'dup', fd: from, target: toNum }); continue; }
+      const target = tokens[++i];
+      out.redirs.push({ kind: op === '<' ? 'read' : 'write', fd: from, path: target, append: op === '>>' });
+      continue;
+    }
+    out.args.push(t);
+  }
+  return out;
+}
+
+export function makeExecBuiltin(ctx, fdTable) {
+  return args => {
+    if (!args.length) return;
+    for (const a of args) {
+      const m = a.match(/^(\d+)>(>?)(.+)$/);
+      if (m) { fdTable.open(m[1], m[3], m[2] === '>' ? 'a' : 'w'); continue; }
+      const r = a.match(/^(\d+)<(.+)$/);
+      if (r) { fdTable.open(r[1], r[2], 'r'); continue; }
+      const d = a.match(/^(\d+)>&(\d+)$/);
+      if (d) { fdTable.dup2(d[2], d[1]); continue; }
+      const c = a.match(/^(\d+)>&-$/);
+      if (c) { fdTable.close(c[1]); continue; }
+    }
+  };
+}

package/docs/shell-jobs.js

@@ -0,0 +1,86 @@
+import { createMachine, createActor } from './vendor/xstate.js';
+
+const jobMachine = createMachine({
+  id: 'job', initial: 'running',
+  states: {
+    running: { on: { STOP: 'stopped', DONE: 'done', FAIL: 'failed', SIGNAL: { actions: 'deliverSignal' } } },
+    stopped: { on: { CONT: 'running', DONE: 'done', SIGNAL: { actions: 'deliverSignal' } } },
+    done: { type: 'final' },
+    failed: { type: 'final' },
+  },
+});
+
+export function createJobRegistry(ctx) {
+  ctx.bgJobs = ctx.bgJobs || {};
+  let nextId = 1;
+
+  function spawnJob(cmd, runPipeline) {
+    const id = String(nextId++);
+    const actor = createActor(jobMachine.provide({
+      actions: {
+        deliverSignal: (_, ev) => {
+          if (ev?.sig && ctx.signals) ctx.signals.raise(ev.sig);
+        },
+      },
+    }));
+    actor.start();
+    const job = { id, cmd, actor, done: false, stopped: false, killed: false, startedAt: Date.now() };
+    const p = (async () => {
+      try { await runPipeline(cmd); job.exit = ctx.lastExitCode; actor.send({ type: 'DONE' }); }
+      catch (e) { job.error = e.message; actor.send({ type: 'FAIL' }); }
+      finally { job.done = true; }
+    })();
+    job.promise = p;
+    ctx.bgJobs[id] = job;
+    if (ctx.swJobs) ctx.swJobs.register(id, cmd).catch(() => {});
+    return id;
+  }
+
+  function list() {
+    return Object.values(ctx.bgJobs).map(j => ({ id: j.id, cmd: j.cmd, state: j.actor?.getSnapshot().value || 'unknown', done: j.done, stopped: j.stopped }));
+  }
+
+  function resolve(ref) {
+    const id = ref.startsWith('%') ? ref.slice(1) : ref;
+    if (id === '+' || !id) { const keys = Object.keys(ctx.bgJobs); return ctx.bgJobs[keys[keys.length - 1]]; }
+    return ctx.bgJobs[id];
+  }
+
+  return { spawnJob, list, resolve };
+}
+
+export function makeJobsBuiltin(ctx, registry) {
+  return args => {
+    const long = args.includes('-l');
+    for (const j of registry.list()) ctx.term.write('[' + j.id + ']  ' + (j.stopped ? 'Stopped' : j.done ? 'Done' : 'Running') + (long ? '  ' + j.id : '') + '  ' + j.cmd + '\r\n');
+  };
+}
+
+export function makeFgBuiltin(ctx, registry) {
+  return async args => {
+    const job = registry.resolve(args[0] || '+');
+    if (!job) { ctx.term.write('fg: no such job\r\n'); ctx.lastExitCode = 1; return; }
+    if (job.stopped) { job.actor.send({ type: 'CONT' }); job.stopped = false; }
+    ctx.currentJob = job;
+    try { await job.promise; } finally { ctx.currentJob = null; }
+    ctx.lastExitCode = job.exit ?? (job.error ? 1 : 0);
+  };
+}
+
+export function makeBgBuiltin(ctx, registry) {
+  return args => {
+    const job = registry.resolve(args[0] || '+');
+    if (!job) { ctx.term.write('bg: no such job\r\n'); ctx.lastExitCode = 1; return; }
+    if (job.stopped) { job.actor.send({ type: 'CONT' }); job.stopped = false; }
+    ctx.term.write('[' + job.id + ']+ ' + job.cmd + ' &\r\n');
+  };
+}
+
+export function makeDisownBuiltin(ctx) {
+  return args => {
+    for (const a of args) {
+      const id = a.startsWith('%') ? a.slice(1) : a;
+      if (ctx.bgJobs[id]) { ctx.bgJobs[id].disowned = true; delete ctx.bgJobs[id]; }
+    }
+  };
+}

package/docs/shell-node-advanced.js

@@ -0,0 +1,86 @@
+export function makeStreamingZlib(streamMod,Buf,fflate){
+  const Transform=streamMod.Transform;
+  const mkT=(Klass,errMsg)=>()=>{let inst=null;const chunks=[];const out=new Transform({transform(c,e,cb){try{if(!inst)inst=new fflate[Klass]((chunk,fin)=>{out.push(Buf.from(chunk));});inst.push(c instanceof Uint8Array?c:new TextEncoder().encode(String(c)),false);cb();}catch(e){cb(e);}},flush(cb){try{if(inst)inst.push(new Uint8Array(0),true);cb();}catch(e){cb(e);}}});return out;};
+  return{
+    createGzip:mkT('Gzip'),
+    createGunzip:mkT('Gunzip'),
+    createDeflate:mkT('Deflate'),
+    createInflate:mkT('Inflate'),
+    createDeflateRaw:mkT('Deflate'),
+    createInflateRaw:mkT('Inflate'),
+    createBrotliCompress:()=>{throw new Error('brotli: not in webcrypto/CompressionStream — use gzip instead');},
+    createBrotliDecompress:()=>{throw new Error('brotli: not supported in browser');},
+    brotliCompressSync:()=>{throw new Error('brotli: not supported — use gzipSync');},
+    brotliDecompressSync:()=>{throw new Error('brotli: not supported');},
+  };
+}
+
+export function makeVmModule(){
+  const contexts=new WeakMap();
+  const registry=typeof FinalizationRegistry!=='undefined'?new FinalizationRegistry(iframe=>{try{iframe.remove();}catch{}}):{register(){}};
+  const hasDom=typeof document!=='undefined';
+  const cloneAcross=v=>{if(v==null||typeof v!=='object'&&typeof v!=='function')return v;if(typeof v==='function')return v;try{return structuredClone(v);}catch{return v;}};
+  const mkIframe=ctx=>{if(!hasDom)return{iframe:null,win:globalThis};const f=document.createElement('iframe');f.style.display='none';f.setAttribute('sandbox','allow-scripts allow-same-origin');document.body.appendChild(f);const win=f.contentWindow;if(ctx)for(const k of Object.keys(ctx))win[k]=cloneAcross(ctx[k]);registry.register(ctx||{},f);return{iframe:f,win};};
+  const syncBack=(ctx,win)=>{for(const k of Object.keys(ctx))if(k in win)ctx[k]=cloneAcross(win[k]);for(const k of Object.keys(win))if(!(k in ctx)&&!['window','self','document','location','navigator','parent','top','frames','opener','localStorage','sessionStorage'].includes(k))ctx[k]=cloneAcross(win[k]);};
+  return{
+    runInThisContext:code=>(0,eval)(code),
+    runInNewContext:(code,ctx={})=>{const{win}=mkIframe(ctx);const r=win.eval?win.eval(code):(0,eval)(code);if(win.eval)syncBack(ctx,win);return cloneAcross(r);},
+    runInContext:(code,ctxObj)=>{const ref=contexts.get(ctxObj);if(!ref)throw new Error('vm.runInContext: context not created via createContext');const r=ref.win.eval(code);syncBack(ctxObj,ref.win);return cloneAcross(r);},
+    createContext:(ctx={})=>{const ref=mkIframe(ctx);contexts.set(ctx,ref);return ctx;},
+    isContext:ctx=>contexts.has(ctx),
+    Script:class Script{constructor(code){this.code=code;}runInThisContext(){return(0,eval)(this.code);}runInNewContext(ctx={}){const{win}=mkIframe(ctx);const r=win.eval?win.eval(this.code):(0,eval)(this.code);if(win.eval)syncBack(ctx,win);return cloneAcross(r);}runInContext(ctx){const ref=contexts.get(ctx);if(!ref)throw new Error('Script.runInContext: createContext first');const r=ref.win.eval(this.code);syncBack(ctx,ref.win);return cloneAcross(r);}},
+    compileFunction:(code,params=[])=>new Function(...params,code),
+  };
+}
+
+export function makeModuleRegister(MODULES,snap,pathmod){
+  const hooks=[];
+  return{
+    register(specifier,parentURL){hooks.push({specifier,parentURL:parentURL||'file:///'});return{addEventListener(){}};},
+    _runResolve:async(specifier,context)=>{let result={url:specifier,shortCircuit:false};for(const h of hooks){try{const m=await import(h.specifier);if(m.resolve){const nextResolve=async(s,c)=>({url:s,shortCircuit:true});const r=await m.resolve(specifier,context,nextResolve);if(r&&r.shortCircuit){result=r;break;}if(r)result=r;}}catch{}}return result;},
+    _runLoad:async(url,context)=>{let result={format:'module',source:null,shortCircuit:false};for(const h of hooks){try{const m=await import(h.specifier);if(m.load){const nextLoad=async(u,c)=>({format:'module',source:null,shortCircuit:true});const r=await m.load(url,context,nextLoad);if(r&&r.shortCircuit){result=r;break;}if(r)result=r;}}catch{}}return result;},
+    _hooks:hooks,
+  };
+}
+
+export function makeHttp2(){
+  const mkStream=()=>{const handlers={};const on=(e,f)=>{(handlers[e]=handlers[e]||[]).push(f);return stream;};const emit=(e,...a)=>{for(const f of handlers[e]||[])f(...a);};const stream={on,once:on,emit,close(){emit('close');},end(){emit('end');},write(){},pipe:d=>d,setEncoding(){return stream;}};return{stream,emit};};
+  return{
+    connect(authority){
+      const h={};let closed=false;
+      const session={
+        on:(e,f)=>{(h[e]=h[e]||[]).push(f);return session;},
+        once:(e,f)=>session.on(e,f),
+        emit:(e,...a)=>{for(const f of h[e]||[])f(...a);},
+        close(){closed=true;session.emit('close');},
+        destroy(){closed=true;session.emit('close');},
+        request(headers){
+          const {stream,emit}=mkStream();
+          const method=headers[':method']||'GET';
+          const path=headers[':path']||'/';
+          const url=authority.toString().replace(/\/$/,'')+path;
+          const fetchHeaders={};for(const[k,v]of Object.entries(headers))if(!k.startsWith(':'))fetchHeaders[k]=v;
+          fetch(url,{method,headers:fetchHeaders}).then(async r=>{const respHeaders={':status':r.status};r.headers.forEach((v,k)=>{respHeaders[k]=v;});emit('response',respHeaders,0);const reader=r.body?.getReader();if(reader)for(;;){const{value,done}=await reader.read();if(done)break;emit('data',new Uint8Array(value));}emit('end');emit('close');}).catch(e=>emit('error',e));
+          return stream;
+        },
+      };
+      queueMicrotask(()=>session.emit('connect',session));
+      return session;
+    },
+    constants:{NGHTTP2_REFUSED_STREAM:0xb,HTTP2_HEADER_METHOD:':method',HTTP2_HEADER_PATH:':path',HTTP2_HEADER_STATUS:':status'},
+  };
+}
+
+let wasiPromise=null;
+async function getWasi(){if(!wasiPromise)wasiPromise=import('https://esm.sh/@bjorn3/browser_wasi_shim@0.3.0/es2022/browser_wasi_shim.mjs').then(m=>m.default||m);return wasiPromise;}
+
+export function makeWasi(){
+  return{
+    WASI:class WASI{
+      constructor(opts={}){this._opts=opts;this._lib=null;this.wasiImport={};}
+      async _load(){if(!this._lib){this._lib=await getWasi();const args=this._opts.args||[];const env=Object.entries(this._opts.env||{}).map(([k,v])=>`${k}=${v}`);const fds=[new this._lib.OpenFile(new this._lib.File([])),new this._lib.OpenFile(new this._lib.File([])),new this._lib.OpenFile(new this._lib.File([]))];this._wasi=new this._lib.WASI(args,env,fds);this.wasiImport=this._wasi.wasiImport;}return this._wasi;}
+      async start(instance){await this._load();return this._wasi.start(instance);}
+      async initialize(instance){await this._load();return this._wasi.initialize(instance);}
+    }
+  };
+}

package/docs/shell-node-brotli.js

@@ -0,0 +1,22 @@
+let brotliMod=null;let brotliPromise=null;
+
+async function loadBrotli(){
+  if(!brotliPromise)brotliPromise=import('https://esm.sh/brotli-wasm@3.0.1/es2022/brotli-wasm.mjs').then(async m=>{const lib=m.default||m;if(lib.then)return await lib;if(lib.compress&&lib.decompress)return lib;return lib;});
+  return brotliPromise;
+}
+
+export async function preloadBrotli(){brotliMod=await loadBrotli();return brotliMod;}
+
+export function makeBrotli(streamMod,Buf){
+  const need=()=>{if(!brotliMod)throw new Error('brotli: call preloadBrotli() once before sync brotli calls (auto-preloaded on node entry)');return brotliMod;};
+  const toBytes=d=>d instanceof Uint8Array?d:new TextEncoder().encode(String(d));
+  const encodeErr=fn=>{try{return fn();}catch(e){throw new Error('brotli: '+e.message);}};
+  return{
+    brotliCompressSync:b=>Buf.from(encodeErr(()=>need().compress(toBytes(b)))),
+    brotliDecompressSync:b=>Buf.from(encodeErr(()=>need().decompress(toBytes(b)))),
+    brotliCompress:async(b,cb)=>{try{await loadBrotli();const out=Buf.from(need().compress(toBytes(b)));if(cb)cb(null,out);return out;}catch(e){if(cb)cb(e);else throw e;}},
+    brotliDecompress:async(b,cb)=>{try{await loadBrotli();const out=Buf.from(need().decompress(toBytes(b)));if(cb)cb(null,out);return out;}catch(e){if(cb)cb(e);else throw e;}},
+    createBrotliCompress:()=>{const chunks=[];return new streamMod.Transform({transform(c,e,cb){chunks.push(toBytes(c));cb();},flush(cb){try{const all=new Uint8Array(chunks.reduce((s,c)=>s+c.length,0));let off=0;for(const c of chunks){all.set(c,off);off+=c.length;}this.push(Buf.from(need().compress(all)));cb();}catch(e){cb(e);}}});},
+    createBrotliDecompress:()=>{const chunks=[];return new streamMod.Transform({transform(c,e,cb){chunks.push(toBytes(c));cb();},flush(cb){try{const all=new Uint8Array(chunks.reduce((s,c)=>s+c.length,0));let off=0;for(const c of chunks){all.set(c,off);off+=c.length;}this.push(Buf.from(need().decompress(all)));cb();}catch(e){cb(e);}}});},
+  };
+}

package/docs/shell-node-busnet.js

@@ -0,0 +1,90 @@
+const BUS_CHAN='plugkit-busnet';
+const bus=typeof BroadcastChannel!=='undefined'?new BroadcastChannel(BUS_CHAN):null;
+const listeners=new Map();
+const connections=new Map();let connSeq=1;
+const serviceRegistry=new Map();
+let _origin=null;
+function getOrigin(){if(_origin)return _origin;_origin=(globalThis.crypto?.randomUUID?.()||String(Math.random())).slice(0,8);return _origin;}
+
+function handleMsg(m){
+  if(!m)return;
+  if(m.type==='discover'&&m.origin!==getOrigin()){for(const[port,l] of listeners)post({type:'announce',port,service:l.service,origin:getOrigin()});return;}
+  if(m.type==='connect'&&listeners.has(m.port)){const l=listeners.get(m.port);const conn=createConnection(m.id,m.from,true);l.onConnection?.(conn);connections.set(m.id,conn);post({type:'connected',id:m.id,from:getOrigin(),to:m.from});return;}
+  if(m.type==='connected'&&connections.has(m.id)){queueMicrotask(()=>connections.get(m.id)?._onOpen());return;}
+  if(m.type==='data'&&connections.has(m.id)&&m.from!==null&&m.to===getOrigin()){connections.get(m.id)._onData(m.data);return;}
+  if(m.type==='data-local'&&connections.has(m.id)){connections.get(m.id)._onData(m.data);return;}
+  if(m.type==='close'&&connections.has(m.id)){connections.get(m.id)._onClose();connections.delete(m.id);return;}
+  if(m.type==='announce'&&m.origin!==getOrigin()){serviceRegistry.set(m.port+'@'+m.origin,{port:m.port,service:m.service,origin:m.origin,seen:Date.now()});return;}
+}
+
+function post(msg){if(bus)bus.postMessage(msg);}
+
+if(bus)bus.addEventListener('message',e=>{if(e.data?.origin===getOrigin())return;handleMsg(e.data);});
+
+function createConnection(id,remote,fromServer=false){
+  const handlers={data:[],end:[],close:[],open:[],error:[]};
+  const conn={
+    id,remote,fromServer,readable:true,writable:true,
+    on(ev,fn){(handlers[ev]=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){handlers[ev]=(handlers[ev]||[]).filter(x=>x!==fn);return this;},
+    write(data){const peer=connections.get(conn._peerId);if(peer){queueMicrotask(()=>peer._onData(data));return true;}post({type:'data',id,data,from:getOrigin(),to:remote});return true;},
+    end(data){if(data)conn.write(data);for(const h of handlers.close)h();connections.delete(id);},
+    destroy(){for(const h of handlers.close)h();connections.delete(id);},
+    _onOpen(){for(const h of handlers.open)h();},
+    _onData(d){for(const h of handlers.data)h(d);},
+    _onClose(){for(const h of handlers.close)h();},
+    _onError(e){for(const h of handlers.error)h(e);},
+    _peerId:null,
+  };
+  return conn;
+}
+
+export function makeBusnet(){
+  return{
+    listen(port,service,onConnection){
+      if(listeners.has(port))throw Object.assign(new Error('EADDRINUSE'),{code:'EADDRINUSE',port});
+      listeners.set(port,{port,service:service||'generic',onConnection,origin:getOrigin()});
+      if(bus)bus.postMessage({type:'announce',port,service:service||'generic',origin:getOrigin()});
+      return{port,close:()=>{listeners.delete(port);}};
+    },
+    connect(port,targetOrigin,cb){
+      const id=getOrigin()+'-'+(connSeq++);
+      const clientConn=createConnection(id,targetOrigin);
+      connections.set(id,clientConn);
+      if(cb)clientConn.on('open',cb);
+      if(listeners.has(port)&&(!targetOrigin||targetOrigin===getOrigin())){
+        const srvId=id+'-srv';
+        const serverConn=createConnection(srvId,getOrigin(),true);
+        connections.set(srvId,serverConn);
+        clientConn._peerId=srvId; serverConn._peerId=id;
+        const l=listeners.get(port);
+        queueMicrotask(()=>{l.onConnection?.(serverConn);serverConn._onOpen();clientConn._onOpen();});
+      }else{
+        post({type:'connect',id,port,from:getOrigin(),to:targetOrigin});
+      }
+      return clientConn;
+    },
+    discover(filter){
+      if(bus)bus.postMessage({type:'discover',origin:getOrigin()});
+      return new Promise(r=>setTimeout(()=>{const out=[...serviceRegistry.values()];r(filter?.service?out.filter(s=>s.service===filter.service):out);},200));
+    },
+    getListeners(){return[...listeners.keys()];},
+    getServices(){return[...serviceRegistry.values()];},
+    origin:getOrigin(),
+    _bus:bus,
+  };
+}
+
+export function makeBusHttp(busnet){
+  const respond=(conn,status,headers,body)=>{const res=`HTTP/1.1 ${status} ${status===200?'OK':'ERR'}\r\n`+Object.entries(headers||{}).map(([k,v])=>`${k}: ${v}`).join('\r\n')+`\r\nContent-Length: ${body.length}\r\n\r\n${body}`;conn.write(res);};
+  return{
+    createServer(handler){
+      return{
+        listen(port,host,cb){if(typeof host==='function'){cb=host;host=null;}busnet.listen(port,'http',conn=>{conn.on('data',raw=>{const[reqLine,...rest]=String(raw).split('\r\n');const[method,url]=reqLine.split(' ');const bodyIdx=rest.indexOf('');const headers={};for(const line of rest.slice(0,bodyIdx)){const [k,v]=line.split(':');if(k)headers[k.trim().toLowerCase()]=v?.trim();}const req={method,url,headers,body:rest.slice(bodyIdx+1).join('\r\n')};const res={statusCode:200,_headers:{},setHeader(k,v){this._headers[k]=v;},end(body){respond(conn,this.statusCode,this._headers,body||'');conn.end();}};handler(req,res);});});cb?.();return this;},
+        close(cb){cb?.();},
+      };
+    },
+    request(opts,cb){const port=opts.port,targetOrigin=opts.origin||null;const conn=busnet.connect(port,targetOrigin,()=>{const path=opts.path||'/';const method=opts.method||'GET';const hdrs=Object.entries(opts.headers||{}).map(([k,v])=>`${k}: ${v}`).join('\r\n');conn.write(`${method} ${path} HTTP/1.1\r\n${hdrs}\r\n\r\n`);});const handlers={response:[]};conn.on('data',raw=>{const[status,...rest]=String(raw).split('\r\n');const s=status.match(/HTTP\/\S+\s+(\d+)/);const bodyIdx=rest.indexOf('');const headers={};for(const line of rest.slice(0,bodyIdx)){const [k,v]=line.split(':');if(k)headers[k.trim().toLowerCase()]=v?.trim();}const body=rest.slice(bodyIdx+1).join('\r\n');const res={statusCode:s?+s[1]:200,headers,body,on(ev,fn){if(ev==='data')queueMicrotask(()=>fn(body));if(ev==='end')queueMicrotask(()=>fn());return res;}};for(const h of handlers.response)h(res);cb?.(res);});const req={on(ev,fn){if(ev==='response')handlers.response.push(fn);return req;},end(){},write(){}};return req;},
+  };
+}