thebird 1.2.79 → 1.2.81

package/docs/shell-node.js

@@ -1,193 +1,199 @@
 import { createPath, createFs, createEvents, createUrl, createQuerystring, createBuffer } from './node-builtins.js';
-
-function serializeRoutes(routes) {
-  const out = {};
-  for (const [method, arr] of Object.entries(routes)) out[method] = arr.map(r => ({ path: r.path }));
-  return out;
-}
-
-function matchRoute(pattern, path) {
-  if (pattern === '*') return {};
-  const pp = pattern.split('/'), rp = path.split('/');
-  if (pp.length !== rp.length) return null;
-  const params = {};
-  for (let i = 0; i < pp.length; i++) {
-    if (pp[i].startsWith(':')) params[pp[i].slice(1)] = rp[i];
-    else if (pp[i] !== rp[i]) return null;
-  }
-  return params;
-}
-
-function createExpress(term, fsmod) {
-  return () => {
-    const routes = { GET: [], POST: [], PUT: [], DELETE: [], USE: [] };
-    const middlewares = [];
-    const app = fn => middlewares.push(fn);
-    app.get = (p, ...fns) => routes.GET.push({ path: p, fns });
-    app.post = (p, ...fns) => routes.POST.push({ path: p, fns });
-    app.put = (p, ...fns) => routes.PUT.push({ path: p, fns });
-    app.delete = (p, ...fns) => routes.DELETE.push({ path: p, fns });
-    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;
-  };
-}
-
-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() {}
-  };
-}
-
-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, opts) => 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: () => {},
-  };
-}
-
-function createProcess(term, ctx) {
-  return {
-    argv: ['node'],
-    env: ctx.env,
-    cwd: () => ctx.cwd,
-    chdir: d => { ctx.cwd = d; },
-    exit: code => term.write('[exit ' + (code || 0) + ']\r\n'),
-    platform: 'browser',
-    version: 'v20.0.0',
-    versions: { node: '20.0.0' },
-    pid: 1,
-    nextTick: fn => Promise.resolve().then(fn),
-    stdout: { write: s => term.write(String(s)) },
-    stderr: { write: s => term.write('\x1b[31m' + String(s) + '\x1b[0m') },
-    stdin: { on: () => {} },
-    on: () => {},
-    off: () => {},
-    hrtime: { bigint: () => BigInt(Math.round(performance.now() * 1e6)) },
-  };
-}
+import { createExpress, createHttp, createSqlite, createConsole, createProcess, NODE_VERSION, NODE_VERSIONS, NodeExit } from './shell-node-modules.js';
+import { inspect, format, createZlib, preloadFflate } from './shell-node-stdlib.js';
+import { createHash, createHmac, pbkdf2Sync, randomBytes } from './shell-node-crypto.js';
+import { createChildProcess, createHttpClient, extendProcess, rewriteStack, isEsmCode, runEsm, parseDotEnv } from './shell-node-io.js';
+import { resolveExports, resolveImports, walkUpNodeModules, resolvePackageEntry, makeModuleModule, makeModuleNotFoundError, makeFsPromises, makeFsWatch, makeNetStub, makeDgramStub, makeWorkerThreadsStub } from './shell-node-resolve.js';
+import { extendBuffer, extendPath, createUrlExt, makeStringDecoder, makeReadline, makeTimersMod, makePerfHooks, makeV8Mod, makeAsyncHooks, makeStubs, makeErrorCodes, extendProcessExtras, makeStreamConsumers } from './shell-node-extras.js';
+import { makeStream, extendFsStreams } from './shell-node-streams.js';
+import { extendCrypto } from './shell-node-cipher.js';
+import { extendKeys } from './shell-node-keyobject.js';
+import { makeStreamingZlib, makeVmModule, makeModuleRegister, makeHttp2, makeWasi } from './shell-node-advanced.js';
+import { makeDebugRegistry, makeDiagnosticsChannel, makeTraceEvents, makeBufferPool, makeProcessBindings, makePerfMemory, makeFetchPool, makeFsWatchReal, installPrepareStackTraceHook, installCaptureStackTrace } from './shell-node-observe.js';
+import { makeWorkerThreads, makeChildProcessReal, makeRepl } from './shell-node-runtime.js';
+import { detectBrowser, registerPolyfill, makeCompressionStreamZlib, makeWebCodecs, makeWebPush, makeStorageHelpers } from './shell-node-firefox.js';
+import { makeOpfsBackend, wireOpfsIntoFs } from './shell-node-opfs.js';
+import { preloadBrotli, makeBrotli } from './shell-node-brotli.js';
+import { preloadSourceMap, installSourceMapStacks } from './shell-node-srcmap.js';
+import { makeNet, makeTls, makeDgram } from './shell-node-net.js';
+import { makeInspector } from './shell-node-inspector.js';
+import { makeV8Profiler, makeHeapSnapshot } from './shell-node-profiler.js';
+import { makeCluster } from './shell-node-cluster.js';
+import { preloadX509 } from './shell-node-keyobject.js';
+import { detectRuntime, registerRuntime, switchRuntime, logRuntimeSwitch } from './shell-runtime.js';
+import { makeDenoGlobal } from './shell-deno.js'; import { makeBunGlobal } from './shell-bun.js';
+import { makePmDispatcher, detectPm, makeCorepackStub } from './shell-pm.js';
+import { isTsFile, preprocessSource } from './shell-ts.js'; import { installPosixFs, installFds, installTmpAndMisc } from './shell-posix.js';
+import { makeTestRunner, makeTapReporter } from './shell-node-testrunner.js'; import { makeForkIpc } from './shell-node-ipc.js';
+import { styleText, stripVTControlCharacters, getCallSites, MIMEType, MIMEParams, makeConsoleExtras } from './shell-node-util-extras.js';
+import { makeProcFs, wireProcFs } from './shell-node-procfs.js'; import { makeGit } from './shell-node-git.js'; import { makeTar } from './shell-node-tar.js'; import { makeDns } from './shell-node-dns.js'; import { makeNativeLoader } from './shell-node-native.js'; import { makeRegistry } from './shell-node-registry.js';
+import { makeBusnet, makeBusHttp } from './shell-node-busnet.js';
 
 export function createNodeEnv({ ctx, term }) {
-  const pathmod = createPath();
-  const fsmod = createFs();
-  const Buf = createBuffer();
+  const pathmod = extendPath(createPath()); const Buf = makeBufferPool(extendBuffer(createBuffer())); const debugReg = makeDebugRegistry();
+  const browserInfo = detectBrowser(); debugReg.browser = browserInfo; const snapFn = () => window.__debug?.idbSnapshot || {};
+  const fsmod = installTmpAndMisc(installFds(installPosixFs(extendFsStreams(createFs(), Buf), Buf, ctx), Buf), Buf, ctx);
+  const opfs = makeOpfsBackend(Buf); if (opfs) wireOpfsIntoFs(fsmod, opfs, debugReg);
+  const runtime = detectRuntime(); registerRuntime(debugReg, runtime); fsmod.promises = makeFsPromises(fsmod); fsmod.watch = makeFsWatchReal(snapFn);
+  fsmod.glob = (pat, opts, cb) => { if (typeof opts === 'function') { cb = opts; opts = {}; } const matches = Object.keys(window.__debug?.idbSnapshot || {}).filter(k => new RegExp('^' + pat.replace(/\*\*/g, '.+').replace(/\*/g, '[^/]*') + '$').test(k)); queueMicrotask(() => cb?.(null, matches)); };
+  fsmod.globSync = pat => Object.keys(window.__debug?.idbSnapshot || {}).filter(k => new RegExp('^' + pat.replace(/\*\*/g, '.+').replace(/\*/g, '[^/]*') + '$').test(k));
+  const zlibMod = createZlib(Buf); const httpClient = createHttpClient(Buf); const cpMod = createChildProcess(ctx); const streamMod = makeStream();
+  const cpReal = makeChildProcessReal(Buf, streamMod); Object.assign(cpMod, { exec: cpReal.exec.bind(cpReal), spawn: cpReal.spawn.bind(cpReal), execFile: cpReal.execFile.bind(cpReal), execSync: cpReal.execSync, spawnSync: cpReal.spawnSync, fork: cpReal.fork });
+  let cryptoMod = { createHash, createHmac, pbkdf2Sync, pbkdf2: (pw, salt, iter, len, dig, cb) => queueMicrotask(() => { try { cb(null, Buf.from(pbkdf2Sync(pw, salt, iter, len, dig))); } catch (e) { cb(e); } }), randomBytes: n => Buf.from(randomBytes(n)), randomUUID: () => crypto.randomUUID(), randomInt: (a, b) => Math.floor(Math.random() * (b - a) + a), webcrypto: globalThis.crypto, constants: {} };
+  cryptoMod = extendKeys(extendCrypto(cryptoMod, Buf)); cryptoMod._ops = () => ++debugReg.cryptoOps; cryptoMod.secureHeapUsed = () => ({ total: 0, min: 0, used: 0, utilization: 0 });
+  const errorCodes = makeErrorCodes(); const stubs = makeStubs(ctx); const diagCh = makeDiagnosticsChannel(); const traceEv = makeTraceEvents(debugReg);
+  const vmMod = makeVmModule(); const http2Mod = makeHttp2(); const wasiMod = makeWasi(); const moduleRegister = makeModuleRegister(); const workerThreads = makeWorkerThreads(snapFn, Buf);
+  const getMem = makePerfMemory(performance); const FetchAgent = makeFetchPool(); const netMod = makeNet(Buf); const tlsMod = makeTls(netMod, Buf); const dgramMod = makeDgram(Buf);
+  const v8Real = makeV8Profiler(debugReg); const heapSnap = makeHeapSnapshot(); const clusterReal = makeCluster(); const inspector = makeInspector(debugReg);
+  const nativeCS = makeCompressionStreamZlib(streamMod, Buf); const webCodecs = makeWebCodecs(); const webPush = makeWebPush(); const storage = makeStorageHelpers();
+  const gitMod = makeGit(fsmod); const tarMod = makeTar(fsmod, null, Buf); const dnsMod = makeDns(); const nativeLoader = makeNativeLoader(); const registryMod = makeRegistry(); const busnet = makeBusnet(); globalThis.__busnet = busnet; const busHttp = makeBusHttp(busnet); debugReg.busnet = busnet;
+  if (nativeCS) registerPolyfill(debugReg, 'compressionStream', 'native', 'CompressionStream available'); if (browserInfo.capabilities.webCodecs) registerPolyfill(debugReg, 'webCodecs', 'native', 'WebCodecs available');
+  const proc = extendProcessExtras(extendProcess(createProcess(term, ctx), ctx), ctx);
+  proc.stdin.setRawMode = () => proc.stdin; proc.stdin.isRaw = false; proc.binding = makeProcessBindings(); proc.memoryUsage = getMem; proc.storage = storage; proc.storageBuckets = storage.buckets; proc.cwd = () => ctx.cwd; proc.chdir = p => { ctx.cwd = p.startsWith('/') ? p : pathmod.resolve(ctx.cwd, p); }; proc.umask = m => { const prev = ctx.umask || 0o022; if (m != null) ctx.umask = m; return prev; }; makeForkIpc(proc); proc.dlopen = (t, p) => nativeLoader.dlopen(t, p); proc.resourceUsage = () => { const m = performance.memory || {}; return { userCPUTime: performance.now() * 1000 | 0, systemCPUTime: 0, maxRSS: (m.totalJSHeapSize || 0) / 1024 | 0, sharedMemorySize: 0, unsharedDataSize: 0, unsharedStackSize: 0, minorPageFault: 0, majorPageFault: 0, swappedOut: 0, fsRead: 0, fsWrite: 0, ipcSent: 0, ipcReceived: 0, signalsCount: 0, voluntaryContextSwitches: 0, involuntaryContextSwitches: 0 }; };
+  wireProcFs(fsmod, makeProcFs(proc)); const denoGlobal = makeDenoGlobal(fsmod, proc, cpMod, ctx.httpHandlers || {}, Buf); const bunGlobal = makeBunGlobal(fsmod, proc, cpMod, ctx.httpHandlers || {}, Buf, streamMod, cryptoMod);
   const MODULES = {
-    path: () => pathmod,
-    fs: () => fsmod,
-    events: () => createEvents(),
-    url: () => createUrl(),
-    querystring: () => createQuerystring(),
-    os: () => ({ platform: () => 'browser', homedir: () => '/', tmpdir: () => '/tmp', cpus: () => [{}], totalmem: () => 1073741824, freemem: () => 536870912, hostname: () => 'thebird', EOL: '\n' }),
-    util: () => ({ format: (...a) => a.join(' '), inspect: o => JSON.stringify(o, null, 2), promisify: fn => (...a) => new Promise((r, j) => fn(...a, (e, v) => e ? j(e) : r(v))), types: { isPromise: p => p instanceof Promise } }),
-    crypto: () => ({ randomBytes: n => Buf.from(Array.from({ length: n }, () => Math.random() * 256 | 0)), randomUUID: () => crypto.randomUUID(), createHash: () => ({ update: () => ({ digest: () => 'stub' }) }) }),
-    stream: () => ({ Readable: createEvents(), Writable: createEvents(), Transform: createEvents(), pipeline: (...a) => a.pop()(null) }),
-    express: createExpress(term, fsmod),
-    'better-sqlite3': createSqlite,
+    path: () => pathmod, fs: () => fsmod, events: () => createEvents(), url: () => createUrlExt(), querystring: () => createQuerystring(),
+    os: () => { const n=navigator?.hardwareConcurrency||1; const mem=performance.memory||{}; return { platform: () => 'linux', arch: () => 'x64', homedir: () => ctx.env.HOME || '/root', tmpdir: () => '/tmp', cpus: () => Array.from({length:n},(_,i)=>({model:'Browser CPU',speed:3000,times:{user:0,nice:0,sys:0,idle:0,irq:0}})), totalmem: () => mem.jsHeapSizeLimit || 1073741824, freemem: () => (mem.jsHeapSizeLimit || 1073741824) - (mem.usedJSHeapSize || 0), hostname: () => ctx.env.HOSTNAME || 'thebird', EOL: '\n', release: () => '6.0.0-browser', type: () => 'Linux', uptime: () => performance.now() / 1000, networkInterfaces: () => ({ lo: [{ address: '127.0.0.1', netmask: '255.0.0.0', family: 'IPv4', mac: '00:00:00:00:00:00', internal: true, cidr: '127.0.0.1/8' }] }), loadavg: () => [0, 0, 0], userInfo: () => ({ username: ctx.env.USER || 'root', uid: 0, gid: 0, shell: ctx.env.SHELL || '/bin/sh', homedir: ctx.env.HOME || '/root' }), endianness: () => 'LE', version: () => '#1 SMP', machine: () => 'x86_64', devNull: '/dev/null', availableParallelism: () => n, constants: { signals: { SIGINT: 2, SIGTERM: 15, SIGKILL: 9, SIGHUP: 1 }, errno: { EACCES: 13, EEXIST: 17, ENOENT: 2, EISDIR: 21, ENOTDIR: 20 } } }; },
+    util: () => ({ inspect, format, promisify: fn => (...a) => new Promise((r, j) => fn(...a, (e, v) => e ? j(e) : r(v))), callbackify: fn => (...a) => { const cb = a.pop(); fn(...a).then(v => cb(null, v), e => cb(e)); }, types: { isPromise: p => p instanceof Promise, isDate: v => v instanceof Date, isRegExp: v => v instanceof RegExp, isBuffer: v => v instanceof Uint8Array, isTypedArray: v => ArrayBuffer.isView(v) && !(v instanceof DataView), isAsyncFunction: f => f?.constructor?.name === 'AsyncFunction', isNativeError: e => e instanceof Error }, deprecate: fn => fn, inherits: (a, b) => { Object.setPrototypeOf(a.prototype, b.prototype); }, debuglog: () => () => {}, isDeepStrictEqual: (a, b) => JSON.stringify(a) === JSON.stringify(b), styleText, stripVTControlCharacters, getCallSites, MIMEType, MIMEParams, parseArgs: ({ args = [], options = {} }) => { const values = {}, positionals = []; for (let i = 0; i < args.length; i++) { const a = args[i]; if (a.startsWith('--')) { const [k, v] = a.slice(2).split('='); if (v !== undefined) values[k] = v; else if (options[k]?.type === 'string') values[k] = args[++i]; else values[k] = true; } else positionals.push(a); } return { values, positionals }; } }),
+    crypto: () => cryptoMod,
+    stream: () => streamMod, 'stream/promises': () => streamMod.promises, 'stream/consumers': () => makeStreamConsumers(), 'stream/web': () => ({ ReadableStream, WritableStream, TransformStream }),
+    http: () => ({ ...httpClient, Agent: FetchAgent, globalAgent: new FetchAgent() }), https: () => ({ ...httpClient, Agent: FetchAgent, globalAgent: new FetchAgent() }),
+    http2: () => http2Mod, 'node:http2': () => http2Mod,
+    vm: () => vmMod, 'node:vm': () => vmMod,
+    buffer: () => ({ Buffer: Buf, constants: { MAX_LENGTH: 4294967295, MAX_STRING_LENGTH: 536870888 }, kMaxLength: 4294967295, Blob, File }),
+    child_process: () => cpMod,
+    net: () => netMod, dgram: () => dgramMod, tls: () => tlsMod, worker_threads: () => workerThreads,
+    zlib: () => ({ ...zlibMod, ...makeStreamingZlib(streamMod, Buf, globalThis.__fflate || {}), ...(nativeCS || {}), ...makeBrotli(streamMod, Buf) }),
+    assert: () => { const a = (v, m) => { if (!v) throw new Error(m || 'assertion failed'); }; a.ok = a; a.equal = (x, y, m) => a(x === y, m); a.deepEqual = (x, y, m) => a(JSON.stringify(x) === JSON.stringify(y), m); a.deepStrictEqual = a.deepEqual; a.strictEqual = a.equal; a.notEqual = (x, y, m) => a(x !== y, m); a.notDeepEqual = (x, y, m) => a(JSON.stringify(x) !== JSON.stringify(y), m); a.notStrictEqual = a.notEqual; a.throws = (fn, m) => { try { fn(); throw new Error('did not throw'); } catch (e) {} }; a.doesNotThrow = fn => fn(); a.rejects = async fn => { try { await (typeof fn === 'function' ? fn() : fn); throw new Error('did not reject'); } catch {} }; a.fail = m => { throw new Error(m || 'failed'); }; a.match = (s, re) => a(re.test(s)); return a; },
+    string_decoder: () => stubs.string_decoder, readline: () => makeReadline(term, proc), 'readline/promises': () => stubs.readline_promises,
+    timers: () => makeTimersMod(), 'timers/promises': () => makeTimersMod().promises, perf_hooks: () => makePerfHooks(),
+    v8: () => ({ ...makeV8Mod(), ...v8Real, ...heapSnap }), async_hooks: () => makeAsyncHooks(),
+    inspector: () => inspector, cluster: () => clusterReal || stubs.cluster,
+    codecs: () => { if (!webCodecs) throw makeModuleNotFoundError('codecs', []); return webCodecs; }, 'web-push': () => webPush,
+    sea: () => stubs.sea, 'node:sea': () => stubs.sea, test: () => makeTestRunner(term), 'node:test': () => makeTestRunner(term),
+    'node:test/reporters': () => ({ tap: makeTapReporter(term), spec: class {}, dot: class {} }), tty: () => stubs.tty, domain: () => stubs.domain,
+    diagnostics_channel: () => diagCh, punycode: () => stubs.punycode, errors: () => errorCodes, trace_events: () => traceEv,
+    wasi: () => wasiMod, module: () => ({ ...makeModuleModule(() => {}, MODULES), register: moduleRegister.register, _registerHooks: moduleRegister._hooks }), express: () => createExpress(term, fsmod),
+    'better-sqlite3': createSqlite, sqlite: () => ({ DatabaseSync: createSqlite, StatementSync: class {} }), 'node:sqlite': () => ({ DatabaseSync: createSqlite, StatementSync: class {} }),
+    dns: () => dnsMod, 'dns/promises': () => dnsMod.promises, 'node:dns': () => dnsMod, 'isomorphic-git': () => gitMod, git: () => gitMod, tar: () => tarMod, 'npm-registry-fetch': () => registryMod,
+    busnet: () => busnet, 'bus-http': () => busHttp,
   };
-
+  for (const k of Object.keys(MODULES)) if (!k.startsWith('node:')) MODULES['node:' + k] = MODULES[k];
   const cons = createConsole(term);
-  const proc = createProcess(term, ctx);
+  cons.log = (...a) => term.write(format(...a) + '\r\n'); cons.info = cons.log; cons.error = (...a) => term.write('\x1b[31m' + format(...a) + '\x1b[0m\r\n'); cons.warn = (...a) => term.write('\x1b[33m' + format(...a) + '\x1b[0m\r\n'); cons.debug = cons.log; Object.assign(cons, makeConsoleExtras(cons, term));
+  const pkgCache = {}; const reqCache = {}; let requireStack = [];
+  function loadDotEnv() { const envFile = snapFn()[ctx.cwd.replace(/^\//, '').replace(/\/$/, '') + '/.env'] || snapFn()['.env']; if (!envFile) return; for (const [k, v] of Object.entries(parseDotEnv(envFile))) if (!(k in ctx.env)) ctx.env[k] = v; }
+
+  const resolveCandidates = (dir, id) => [pathmod.resolve(dir, id) + '.js', pathmod.resolve(dir, id), pathmod.resolve(dir, id) + '/index.js', pathmod.resolve(dir, id, 'index.js')];
+  function findPkgJsonDir(s, dir) { let d = dir.replace(/^\//, '').replace(/\/$/, ''); while (true) { const k = (d ? d + '/' : '') + 'package.json'; if (k in s) return d; if (!d) return null; const up = d.slice(0, d.lastIndexOf('/')); if (up === d) return null; d = up; } }
+  function isEsmPkg(s, filePath) { const pjDir = findPkgJsonDir(s, pathmod.dirname(filePath)); try { const pj = JSON.parse(s[(pjDir || '') + (pjDir ? '/' : '') + 'package.json']); return pj.type === 'module'; } catch { return false; } }
 
   function makeRequire(dir) {
-    return function require(id) {
+    const req = function require(id) {
+      if (id === 'module') return makeModuleModule(req, MODULES);
       if (MODULES[id]) return MODULES[id]();
-      const candidates = id.startsWith('.') ? [
-        pathmod.resolve(dir, id) + '.js',
-        pathmod.resolve(dir, id),
-        pathmod.resolve(dir, id) + '/index.js',
-        pathmod.resolve(dir, id, 'index.js'),
-      ] : ['node_modules/' + id + '/index.js'];
-      const s = snap();
-      for (const c of candidates) {
+      const s = snapFn();
+      if (id.startsWith('#')) {
+        const pjRoot = findPkgJsonDir(s, dir);
+        if (pjRoot) { const pj = JSON.parse(s[pjRoot + '/package.json']); const target = resolveImports(pj, id); if (target) { const resolved = pathmod.resolve('/' + pjRoot, target); return loadFile(resolved.replace(/^\//, ''), s); } }
+        throw makeModuleNotFoundError(id, requireStack);
+      }
+      if (!id.startsWith('.')) {
+        if (pkgCache[id]) return pkgCache[id];
+        const pkgDir = walkUpNodeModules(s, dir, id);
+        if (pkgDir) { const entry = resolvePackageEntry(s, pkgDir); if (entry) { const m = loadFile(entry.replace(/^\//, ''), s); if (m) return m; } }
+        throw makeModuleNotFoundError(id, requireStack);
+      }
+      for (const c of resolveCandidates(dir, id)) {
         const key = c.replace(/^\//, '');
-        if (key in s) {
-          if (key.endsWith('.json')) return JSON.parse(s[key]);
-          const mod = { exports: {} };
-          const modDir = pathmod.dirname('/' + key);
-          new Function('module', 'exports', 'require', '__filename', '__dirname', 'process', 'console', 'Buffer', 'setTimeout', 'setInterval', 'clearTimeout', 'clearInterval', 'fetch', s[key])(mod, mod.exports, makeRequire(modDir), '/' + key, modDir, proc, cons, Buf, setTimeout, setInterval, clearTimeout, clearInterval, fetch);
-          return mod.exports;
-        }
+        if (key in s) { const loaded = loadFile(key, s); if (loaded !== undefined) return loaded; }
+      }
+      throw makeModuleNotFoundError(id, requireStack);
+    };
+    function loadFile(key, s) {
+      if (key.endsWith('.json')) return JSON.parse(s[key]);
+      if (reqCache[key]) return reqCache[key].exports;
+      const mod = { exports: {} };
+      reqCache[key] = mod;
+      const modDir = pathmod.dirname('/' + key);
+      requireStack.push('/' + key);
+      try {
+        const src = s[key]; const esm = key.endsWith('.mjs') || (key.endsWith('.js') && isEsmPkg(s, '/' + key)) || isEsmCode(src);
+        if (esm) throw new Error("ESM module '" + key + "' requested via require() — use dynamic import() or run entry as ESM");
+        new Function('module', 'exports', 'require', '__filename', '__dirname', 'process', 'console', 'Buffer', 'setTimeout', 'setInterval', 'clearTimeout', 'clearInterval', 'fetch', src)(mod, mod.exports, makeRequire(modDir), '/' + key, modDir, proc, cons, Buf, setTimeout, setInterval, clearTimeout, clearInterval, fetch);
       }
-      throw new Error('Cannot find module: ' + id);
+      finally { requireStack.pop(); }
+      mod.loaded = true;
+      return mod.exports;
+    }
+    req.resolve = id => {
+      if (MODULES[id] || id === 'module') return id;
+      const s = snapFn();
+      if (!id.startsWith('.')) { const pkgDir = walkUpNodeModules(s, dir, id); if (pkgDir) return resolvePackageEntry(s, pkgDir) || pkgDir; throw makeModuleNotFoundError(id, requireStack); }
+      for (const c of resolveCandidates(dir, id)) { const key = c.replace(/^\//, ''); if (key in s) return '/' + key; }
+      throw makeModuleNotFoundError(id, requireStack);
     };
+    req.cache = reqCache;
+    return req;
   }
 
-  const snap = () => window.__debug?.idbSnapshot || {};
-
-  async function loadSql() {
-    if (window.__sqlJs) return window.__sqlJs;
-    await new Promise((res, rej) => { const s = document.createElement('script'); s.src = './vendor/sql-wasm.js'; s.onload = res; s.onerror = rej; document.head.appendChild(s); });
-    window.__sqlJs = await initSqlJs({ locateFile: f => './vendor/' + f });
-    return window.__sqlJs;
+  async function preloadAsyncPkgs(entryCode, entryDir) {
+    const s = snapFn();
+    const visited = new Set(); const queue = [{ code: entryCode, dir: entryDir }]; const pkgIds = new Set();
+    const re = /require\(\s*['"]([^'"]+)['"]\s*\)/g;
+    while (queue.length) {
+      const { code, dir } = queue.shift(); let m; re.lastIndex = 0;
+      while ((m = re.exec(code))) { const id = m[1]; if (MODULES[id]) continue; if (!id.startsWith('.')) { pkgIds.add(id); continue; } for (const c of resolveCandidates(dir, id)) { const key = c.replace(/^\//, ''); if (visited.has(key) || !(key in s)) continue; visited.add(key); queue.push({ code: s[key], dir: pathmod.dirname('/' + key) }); break; } }
+    }
+    for (const id of pkgIds) {
+      if (pkgCache[id]) continue;
+      const key = 'node_modules/' + id + '/index.js'; if (!(key in s)) continue;
+      const urlMatch = s[key].match(/import\((".+?")\)/); if (!urlMatch) continue;
+      const url = JSON.parse(urlMatch[1]);
+      try { const mod = await import(url); const exp = { ...mod }; if (mod.default && typeof mod.default === 'object') Object.assign(exp, mod.default); pkgCache[id] = mod.default && Object.keys(mod).length === 1 ? mod.default : exp; }
+      catch (e) { term.write('\x1b[31mfailed to load ' + id + ': ' + e.message + '\x1b[0m\r\n'); }
+    }
   }
 
-  return async function nodeEval(code, filename, argv) {
+  return async function nodeEval(code, filename, argv, stdinBuf) {
     const dir = filename ? pathmod.dirname(filename) : ctx.cwd;
-    const fpath = filename || ctx.cwd + '/repl';
-    proc.argv = ['node', fpath, ...(argv || [])];
-    const scope = { process: proc, console: cons, require: makeRequire(dir), Buffer: Buf, __filename: fpath, __dirname: dir, setTimeout, setInterval, clearTimeout, clearInterval, fetch, loadSql, module: { exports: {} }, exports: {} };
+    const fpath = filename || '[eval]';
+    proc.argv = filename ? ['node', fpath, ...(argv || [])] : ['node'];
+    proc.exitCode = 0;
+    loadDotEnv();
+    globalThis.__fflate = await preloadFflate().catch(() => ({}));
+    if (proc.sourceMapsEnabled) { await preloadSourceMap().catch(() => {}); installSourceMapStacks(snapFn); }
+    const rtName = switchRuntime(code.startsWith('#!') ? code.slice(0, code.indexOf('\n')) : ''); logRuntimeSwitch(debugReg, debugReg.runtime.active, rtName, fpath);
+    if (isTsFile(fpath)) code = await preprocessSource(fpath, code);
+    await preloadAsyncPkgs(code, dir);
+    const reqFn = makeRequire(dir);
+    const scope = { process: proc, console: cons, require: reqFn, Buffer: Buf, __filename: fpath, __dirname: dir, setTimeout, setInterval, clearTimeout, clearInterval, fetch, module: { exports: {} }, exports: {}, global: globalThis, URL, URLSearchParams, TextEncoder, TextDecoder };
+    const prevGlobals = { process: globalThis.process, Buffer: globalThis.Buffer, Deno: globalThis.Deno, Bun: globalThis.Bun };
+    globalThis.process = proc; globalThis.Buffer = Buf;
+    if (rtName === 'deno') globalThis.Deno = denoGlobal; else delete globalThis.Deno;
+    if (rtName === 'bun') globalThis.Bun = bunGlobal; else delete globalThis.Bun;
+    installCaptureStackTrace(); installPrepareStackTraceHook();
+    const unhandledH = e => { e.preventDefault?.(); const err = e.reason || e; term.write('\x1b[31m' + rewriteStack(err, fpath) + '\x1b[0m\r\n'); ctx.lastExitCode = 1; };
+    window.addEventListener('unhandledrejection', unhandledH);
     try {
-      const keys = Object.keys(scope);
-      const vals = Object.values(scope);
+      if (isEsmCode(code)) { const preamble = '\nconst __filename = ' + JSON.stringify(fpath) + ';\nconst __dirname = ' + JSON.stringify(dir) + ';\n'; const mod = await runEsm(preamble + code, scope); if (mod && !filename) { for (const [k, v] of Object.entries(mod)) if (k !== 'default') cons.log(k + ':', v); } ctx.lastExitCode = proc.exitCode | 0; return; }
+      const keys = Object.keys(scope), vals = Object.values(scope);
       const fn = new Function(...keys, 'return (async () => {\n' + code + '\n})()');
-      const result = await fn(...vals);
+      const pending = fn(...vals);
+      if (stdinBuf) queueMicrotask(() => proc.stdin._feed(stdinBuf));
+      const result = await pending;
       if (result !== undefined && !filename) cons.log(result);
+      ctx.lastExitCode = proc.exitCode | 0;
     } catch (e) {
-      term.write('\x1b[31m' + (filename ? filename + ': ' : '') + e.message + '\x1b[0m\r\n');
+      if (e && e.__nodeExit) { ctx.lastExitCode = e.code | 0; return; }
+      term.write('\x1b[31m' + rewriteStack(e, fpath) + '\x1b[0m\r\n');
+      ctx.lastExitCode = 1;
+    } finally {
+      window.removeEventListener('unhandledrejection', unhandledH);
+      if (prevGlobals.process !== undefined) globalThis.process = prevGlobals.process; else delete globalThis.process;
+      if (prevGlobals.Buffer !== undefined) globalThis.Buffer = prevGlobals.Buffer; else delete globalThis.Buffer;
+      if (prevGlobals.Deno !== undefined) globalThis.Deno = prevGlobals.Deno; else delete globalThis.Deno;
+      if (prevGlobals.Bun !== undefined) globalThis.Bun = prevGlobals.Bun; else delete globalThis.Bun;
     }
   };
 }

package/docs/shell-npm.js

@@ -0,0 +1,173 @@
+import { NPM_VERSION } from './shell-node-modules.js';
+
+const toKey = p => p.replace(/^\//, '');
+const snap = () => window.__debug.idbSnapshot || {};
+const persist = () => window.__debug.idbPersist?.();
+
+function resolvePkgJson(cwd, ctx) {
+  const path = cwd.replace(/\/$/, '') + '/package.json';
+  const raw = snap()[toKey(path)];
+  if (!raw) throw new Error('npm: no package.json in ' + cwd);
+  try { return { path, data: JSON.parse(raw) }; } catch (e) { throw new Error('npm: invalid package.json: ' + e.message); }
+}
+
+async function installOne(pkg, version, term) {
+  const spec = version && version !== 'latest' ? pkg + '@' + version.replace(/^[\^~]/, '') : pkg;
+  const url = 'https://esm.sh/' + spec + '?bundle&target=es2022';
+  term.write('  → ' + spec + '\r\n');
+  await import(url);
+  const stubPath = 'node_modules/' + pkg + '/index.js';
+  snap()[stubPath] = '// esm.sh async stub\nawait import(' + JSON.stringify(url) + ');';
+  const meta = { name: pkg, version: version || 'latest', _resolved: url, _from: 'esm.sh' };
+  snap()['node_modules/' + pkg + '/package.json'] = JSON.stringify(meta, null, 2);
+  persist();
+}
+
+function writePkgJson(pkgPath, data) {
+  snap()[toKey(pkgPath)] = JSON.stringify(data, null, 2);
+  persist();
+}
+
+function injectNpmEnv(ctx, data, scriptName) {
+  const prev = {};
+  const set = (k, v) => { prev[k] = ctx.env[k]; ctx.env[k] = v; };
+  set('npm_lifecycle_event', scriptName);
+  set('npm_package_name', data.name || '');
+  set('npm_package_version', data.version || '');
+  set('npm_config_user_agent', 'npm/' + NPM_VERSION + ' node/v23.10.0');
+  set('NODE_ENV', ctx.env.NODE_ENV || 'development');
+  for (const [k, v] of Object.entries(data.scripts || {})) set('npm_package_scripts_' + k.replace(/[^a-z0-9_]/gi, '_'), v);
+  return () => { for (const k of Object.keys(prev)) { if (prev[k] === undefined) delete ctx.env[k]; else ctx.env[k] = prev[k]; } };
+}
+
+export function makeNpm(ctx) {
+  const w = s => ctx.term.write(s);
+  const wl = s => w(s + '\r\n');
+
+  async function cmdInstall(args) {
+    const saveDev = args.includes('--save-dev') || args.includes('-D');
+    const noSave = args.includes('--no-save');
+    const pkgs = args.filter(a => !a.startsWith('-'));
+    if (!pkgs.length) {
+      const { data } = resolvePkgJson(ctx.cwd, ctx);
+      const all = { ...(data.dependencies || {}), ...(data.devDependencies || {}), ...(data.peerDependencies || {}) };
+      const entries = Object.entries(all);
+      if (!entries.length) { wl('up to date, 0 packages'); return; }
+      wl('installing ' + entries.length + ' packages from package.json');
+      for (const [name, ver] of entries) await installOne(name, ver, ctx.term);
+      wl('added ' + entries.length + ' package' + (entries.length === 1 ? '' : 's'));
+      return;
+    }
+    for (const spec of pkgs) {
+      const m = spec.match(/^(@?[^@]+?)(?:@(.+))?$/);
+      const [, name, version] = m;
+      await installOne(name, version, ctx.term);
+    }
+    if (!noSave) {
+      const { path: pkgPath, data } = resolvePkgJson(ctx.cwd, ctx);
+      const target = saveDev ? 'devDependencies' : 'dependencies';
+      data[target] = data[target] || {};
+      for (const spec of pkgs) {
+        const m = spec.match(/^(@?[^@]+?)(?:@(.+))?$/);
+        data[target][m[1]] = m[2] || 'latest';
+      }
+      writePkgJson(pkgPath, data);
+    }
+    wl('added ' + pkgs.length + ' package' + (pkgs.length === 1 ? '' : 's'));
+  }
+
+  function cmdUninstall(args) {
+    const pkgs = args.filter(a => !a.startsWith('-'));
+    if (!pkgs.length) throw new Error('npm uninstall <pkg>');
+    for (const pkg of pkgs) {
+      const s = snap();
+      let n = 0;
+      for (const k of Object.keys(s)) {
+        if (k === 'node_modules/' + pkg + '/index.js' || k.startsWith('node_modules/' + pkg + '/')) { delete s[k]; n++; }
+      }
+      wl(n ? 'removed ' + pkg : pkg + ' not installed');
+    }
+    const { path: pkgPath, data } = resolvePkgJson(ctx.cwd, ctx);
+    for (const pkg of pkgs) { delete data.dependencies?.[pkg]; delete data.devDependencies?.[pkg]; }
+    writePkgJson(pkgPath, data);
+    persist();
+  }
+
+  function cmdList(args) {
+    const filter = args.find(a => !a.startsWith('-'));
+    const s = snap();
+    const installed = Object.keys(s).filter(k => k.match(/^node_modules\/[^/]+\/package\.json$/) || k.match(/^node_modules\/@[^/]+\/[^/]+\/package\.json$/));
+    try {
+      const { data } = resolvePkgJson(ctx.cwd, ctx);
+      wl(data.name + '@' + (data.version || '1.0.0') + ' ' + ctx.cwd);
+    } catch { wl('(no package.json)'); }
+    for (const k of installed) {
+      const name = k.replace(/^node_modules\//, '').replace(/\/package\.json$/, '');
+      if (filter && !name.includes(filter)) continue;
+      const pj = JSON.parse(s[k]);
+      wl('├── ' + name + '@' + (pj.version || 'latest'));
+    }
+  }
+
+  async function cmdRun(args) {
+    const [scriptName, ...rest] = args;
+    const { data } = resolvePkgJson(ctx.cwd, ctx);
+    if (!scriptName) {
+      wl('Lifecycle scripts included in ' + (data.name || 'package') + '@' + (data.version || '') + ':');
+      for (const [n, s] of Object.entries(data.scripts || {})) wl('  ' + n + '\r\n    ' + s);
+      return null;
+    }
+    const cmd = data.scripts?.[scriptName];
+    if (!cmd) throw new Error('npm: Missing script: "' + scriptName + '"');
+    const pre = data.scripts?.['pre' + scriptName];
+    const post = data.scripts?.['post' + scriptName];
+    const restore = injectNpmEnv(ctx, data, scriptName);
+    try {
+      const chain = [];
+      if (pre) chain.push({ name: 'pre' + scriptName, cmd: pre });
+      chain.push({ name: scriptName, cmd: cmd + (rest.length ? ' ' + rest.join(' ') : '') });
+      if (post) chain.push({ name: 'post' + scriptName, cmd: post });
+      return { runInShell: null, npmChain: chain, pkgName: data.name || 'package', pkgVersion: data.version || '' };
+    } finally { queueMicrotask(restore); }
+  }
+
+  function cmdInit(args) {
+    const yes = args.includes('-y') || args.includes('--yes');
+    if (!yes) { wl('npm init -y — use -y for non-interactive'); return; }
+    const pj = { name: ctx.cwd.split('/').filter(Boolean).pop() || 'project', version: '1.0.0', main: 'index.js', scripts: { start: 'node index.js', test: 'echo "Error: no test specified" && exit 1' }, dependencies: {} };
+    writePkgJson(ctx.cwd.replace(/\/$/, '') + '/package.json', pj);
+    wl('Wrote to ' + ctx.cwd.replace(/\/$/, '') + '/package.json');
+  }
+
+  async function cmdExec(args) {
+    const pkg = args[0];
+    if (!pkg) throw new Error('npx: package required');
+    const s = snap();
+    if (!s['node_modules/' + pkg + '/index.js']) await installOne(pkg, null, ctx.term);
+    const binPath = 'node_modules/.bin/' + pkg;
+    if (s[binPath]) return { runInShell: 'node /' + binPath + (args.length > 1 ? ' ' + args.slice(1).join(' ') : '') };
+    return { runInShell: 'node -e "require(\'' + pkg + '\')"' };
+  }
+
+  return async function npm(args) {
+    const sub = args[0];
+    const rest = args.slice(1);
+    if (sub === 'install' || sub === 'i' || sub === 'add') return cmdInstall(rest);
+    if (sub === 'uninstall' || sub === 'remove' || sub === 'rm') return cmdUninstall(rest);
+    if (sub === 'ls' || sub === 'list') return cmdList(rest);
+    if (sub === 'run' || sub === 'run-script') return cmdRun(rest);
+    if (sub === 'start') return cmdRun(['start', ...rest]);
+    if (sub === 'test' || sub === 't') return cmdRun(['test', ...rest]);
+    if (sub === 'init' || sub === 'create') return cmdInit(rest);
+    if (sub === 'exec' || sub === 'x') return cmdExec(rest);
+    if (sub === '--version' || sub === '-v') { wl(NPM_VERSION); return; }
+    if (sub === 'prefix') { wl(ctx.cwd); return; }
+    if (sub === 'root') { wl(ctx.cwd.replace(/\/$/, '') + '/node_modules'); return; }
+    if (sub === 'view' || sub === 'info' || sub === 'show') { const p = rest[0]; wl(p + ' — use esm.sh to inspect'); return; }
+    throw new Error('npm: unknown command "' + sub + '"');
+  };
+}
+
+export function makeNpx(npmCmd) {
+  return args => npmCmd(['exec', ...args]);
+}