@jerryan/just-bash 3.6.1 → 3.8.0

package/dist/bin/chunks/js-exec-T3SAB2B6.js

@@ -0,0 +1,1651 @@
+#!/usr/bin/env node
+import{createRequire} from"node:module";const require=createRequire(import.meta.url);
+import{a as ve}from"./chunk-3MRB66F4.js";import{a as me}from"./chunk-3PCPQIUD.js";import{c as pe,d as he}from"./chunk-PPVF2N6C.js";import{a as Se}from"./chunk-MROECM42.js";import{b as w}from"./chunk-HWI42GQO.js";import{b as Y}from"./chunk-CPKBPQ2C.js";import{a as be,b as ge}from"./chunk-OHFB3M3X.js";import{a as S,b as D}from"./chunk-PBOVSFTJ.js";import{a as T}from"./chunk-I4IRHQDW.js";import{b as ye}from"./chunk-MUFNRCMY.js";import"./chunk-DN2YCFOR.js";import{AsyncLocalStorage as et}from"node:async_hooks";import{Buffer as m}from"node:buffer";import{createRunner as tt,getHostFunctionContext as F,RunAbortedError as rt,RunBridgeLimitError as nt,RunError as st,RunTimeoutError as Oe}from"run";var _e=`
+(function() {
+  // --- URLSearchParams ---
+  function URLSearchParams(init) {
+    this._entries = [];
+    if (!init) return;
+    if (typeof init === 'string') {
+      var s = init;
+      if (s.charAt(0) === '?') s = s.slice(1);
+      var pairs = s.split('&');
+      for (var i = 0; i < pairs.length; i++) {
+        var pair = pairs[i];
+        if (pair === '') continue;
+        var eq = pair.indexOf('=');
+        if (eq === -1) {
+          this._entries.push([decodeURIComponent(pair), '']);
+        } else {
+          this._entries.push([
+            decodeURIComponent(pair.slice(0, eq)),
+            decodeURIComponent(pair.slice(eq + 1))
+          ]);
+        }
+      }
+    } else if (typeof init === 'object' && init !== null) {
+      if (init instanceof URLSearchParams) {
+        this._entries = init._entries.slice();
+      } else {
+        var keys = Object.keys(init);
+        for (var i = 0; i < keys.length; i++) {
+          this._entries.push([keys[i], String(init[keys[i]])]);
+        }
+      }
+    }
+  }
+
+  URLSearchParams.prototype.append = function(name, value) {
+    this._entries.push([String(name), String(value)]);
+  };
+
+  URLSearchParams.prototype.delete = function(name) {
+    var n = String(name);
+    this._entries = this._entries.filter(function(e) { return e[0] !== n; });
+  };
+
+  URLSearchParams.prototype.get = function(name) {
+    var n = String(name);
+    for (var i = 0; i < this._entries.length; i++) {
+      if (this._entries[i][0] === n) return this._entries[i][1];
+    }
+    return null;
+  };
+
+  URLSearchParams.prototype.getAll = function(name) {
+    var n = String(name);
+    var result = [];
+    for (var i = 0; i < this._entries.length; i++) {
+      if (this._entries[i][0] === n) result.push(this._entries[i][1]);
+    }
+    return result;
+  };
+
+  URLSearchParams.prototype.has = function(name) {
+    var n = String(name);
+    for (var i = 0; i < this._entries.length; i++) {
+      if (this._entries[i][0] === n) return true;
+    }
+    return false;
+  };
+
+  URLSearchParams.prototype.set = function(name, value) {
+    var n = String(name);
+    var v = String(value);
+    var found = false;
+    var newEntries = [];
+    for (var i = 0; i < this._entries.length; i++) {
+      if (this._entries[i][0] === n) {
+        if (!found) {
+          newEntries.push([n, v]);
+          found = true;
+        }
+      } else {
+        newEntries.push(this._entries[i]);
+      }
+    }
+    if (!found) newEntries.push([n, v]);
+    this._entries = newEntries;
+  };
+
+  URLSearchParams.prototype.sort = function() {
+    this._entries.sort(function(a, b) {
+      if (a[0] < b[0]) return -1;
+      if (a[0] > b[0]) return 1;
+      return 0;
+    });
+  };
+
+  URLSearchParams.prototype.toString = function() {
+    return this._entries.map(function(e) {
+      return encodeURIComponent(e[0]) + '=' + encodeURIComponent(e[1]);
+    }).join('&');
+  };
+
+  URLSearchParams.prototype.forEach = function(callback, thisArg) {
+    for (var i = 0; i < this._entries.length; i++) {
+      callback.call(thisArg, this._entries[i][1], this._entries[i][0], this);
+    }
+  };
+
+  URLSearchParams.prototype.entries = function() {
+    var idx = 0;
+    var entries = this._entries;
+    return {
+      next: function() {
+        if (idx >= entries.length) return { done: true, value: undefined };
+        return { done: false, value: entries[idx++].slice() };
+      },
+      [Symbol.iterator]: function() { return this; }
+    };
+  };
+
+  URLSearchParams.prototype.keys = function() {
+    var idx = 0;
+    var entries = this._entries;
+    return {
+      next: function() {
+        if (idx >= entries.length) return { done: true, value: undefined };
+        return { done: false, value: entries[idx++][0] };
+      },
+      [Symbol.iterator]: function() { return this; }
+    };
+  };
+
+  URLSearchParams.prototype.values = function() {
+    var idx = 0;
+    var entries = this._entries;
+    return {
+      next: function() {
+        if (idx >= entries.length) return { done: true, value: undefined };
+        return { done: false, value: entries[idx++][1] };
+      },
+      [Symbol.iterator]: function() { return this; }
+    };
+  };
+
+  URLSearchParams.prototype[Symbol.iterator] = URLSearchParams.prototype.entries;
+
+  Object.defineProperty(URLSearchParams.prototype, 'size', {
+    get: function() { return this._entries.length; }
+  });
+
+  // --- URL ---
+  var urlRegex = /^([a-zA-Z][a-zA-Z0-9+.-]*):(?:\\/\\/(?:([^:@/?#]*)(?::([^@/?#]*))?@)?([^:/?#]*)(?::([0-9]+))?)?(\\/[^?#]*)?(?:\\?([^#]*))?(?:#(.*))?$/;
+
+  function URL(url, base) {
+    var input = String(url);
+
+    if (base !== undefined) {
+      var baseUrl = (base instanceof URL) ? base : new URL(String(base));
+      // Resolve relative URL against base
+      if (/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(input)) {
+        // Absolute URL - parse as-is
+      } else if (input.charAt(0) === '/' && input.charAt(1) === '/') {
+        // Protocol-relative
+        input = baseUrl.protocol + input;
+      } else if (input.charAt(0) === '/') {
+        // Absolute path
+        input = baseUrl.origin + input;
+      } else if (input.charAt(0) === '?' || input.charAt(0) === '#') {
+        // Query or hash only
+        var basePath = baseUrl.protocol + '//' + baseUrl.host + baseUrl.pathname;
+        if (input.charAt(0) === '#') {
+          input = basePath + baseUrl.search + input;
+        } else {
+          input = basePath + input;
+        }
+      } else {
+        // Relative path
+        var basePath = baseUrl.protocol + '//' + baseUrl.host;
+        var dirPath = baseUrl.pathname;
+        var lastSlash = dirPath.lastIndexOf('/');
+        if (lastSlash >= 0) dirPath = dirPath.slice(0, lastSlash + 1);
+        else dirPath = '/';
+        input = basePath + dirPath + input;
+      }
+    }
+
+    var m = urlRegex.exec(input);
+    if (!m) throw new TypeError("Invalid URL: " + String(url));
+
+    this.protocol = m[1].toLowerCase() + ':';
+    this.username = m[2] ? decodeURIComponent(m[2]) : '';
+    this.password = m[3] ? decodeURIComponent(m[3]) : '';
+    this.hostname = m[4] || '';
+    this.port = m[5] || '';
+    this.pathname = m[6] || '/';
+    this.hash = m[8] ? '#' + m[8] : '';
+
+    // Normalize pathname (resolve . and ..)
+    var parts = this.pathname.split('/');
+    var resolved = [];
+    for (var i = 0; i < parts.length; i++) {
+      if (parts[i] === '..') { if (resolved.length > 1) resolved.pop(); }
+      else if (parts[i] !== '.') resolved.push(parts[i]);
+    }
+    this.pathname = resolved.join('/') || '/';
+
+    // searchParams is live
+    this._searchParamsStr = m[7] || '';
+    this.searchParams = new URLSearchParams(this._searchParamsStr);
+  }
+
+  Object.defineProperty(URL.prototype, 'search', {
+    get: function() {
+      var s = this.searchParams.toString();
+      return s ? '?' + s : '';
+    },
+    set: function(v) {
+      this.searchParams = new URLSearchParams(String(v));
+    }
+  });
+
+  Object.defineProperty(URL.prototype, 'host', {
+    get: function() {
+      return this.port ? this.hostname + ':' + this.port : this.hostname;
+    }
+  });
+
+  Object.defineProperty(URL.prototype, 'origin', {
+    get: function() {
+      return this.protocol + '//' + this.host;
+    }
+  });
+
+  Object.defineProperty(URL.prototype, 'href', {
+    get: function() {
+      var auth = '';
+      if (this.username) {
+        auth = this.username;
+        if (this.password) auth += ':' + this.password;
+        auth += '@';
+      }
+      return this.protocol + '//' + auth + this.host + this.pathname + this.search + this.hash;
+    },
+    set: function(v) {
+      var parsed = new URL(String(v));
+      this.protocol = parsed.protocol;
+      this.username = parsed.username;
+      this.password = parsed.password;
+      this.hostname = parsed.hostname;
+      this.port = parsed.port;
+      this.pathname = parsed.pathname;
+      this.searchParams = parsed.searchParams;
+      this.hash = parsed.hash;
+    }
+  });
+
+  URL.prototype.toString = function() { return this.href; };
+  URL.prototype.toJSON = function() { return this.href; };
+
+  // --- Headers ---
+  function Headers(init) {
+    this._map = Object.create(null);
+    if (!init) return;
+    if (init instanceof Headers) {
+      var keys = Object.keys(init._map);
+      for (var i = 0; i < keys.length; i++) {
+        this._map[keys[i]] = init._map[keys[i]].slice();
+      }
+    } else if (typeof init === 'object') {
+      var keys = Object.keys(init);
+      for (var i = 0; i < keys.length; i++) {
+        this._map[keys[i].toLowerCase()] = [String(init[keys[i]])];
+      }
+    }
+  }
+
+  Headers.prototype.append = function(name, value) {
+    var key = String(name).toLowerCase();
+    if (!Object.prototype.hasOwnProperty.call(this._map, key)) this._map[key] = [];
+    this._map[key].push(String(value));
+  };
+
+  Headers.prototype.delete = function(name) {
+    delete this._map[String(name).toLowerCase()];
+  };
+
+  Headers.prototype.get = function(name) {
+    var vals = this._map[String(name).toLowerCase()];
+    return vals ? vals.join(', ') : null;
+  };
+
+  Headers.prototype.has = function(name) {
+    return Object.prototype.hasOwnProperty.call(this._map, String(name).toLowerCase());
+  };
+
+  Headers.prototype.set = function(name, value) {
+    this._map[String(name).toLowerCase()] = [String(value)];
+  };
+
+  Headers.prototype.forEach = function(callback, thisArg) {
+    var keys = Object.keys(this._map).sort();
+    for (var i = 0; i < keys.length; i++) {
+      callback.call(thisArg, this._map[keys[i]].join(', '), keys[i], this);
+    }
+  };
+
+  Headers.prototype.entries = function() {
+    var keys = Object.keys(this._map).sort();
+    var map = this._map;
+    var idx = 0;
+    return {
+      next: function() {
+        if (idx >= keys.length) return { done: true, value: undefined };
+        var k = keys[idx++];
+        return { done: false, value: [k, map[k].join(', ')] };
+      },
+      [Symbol.iterator]: function() { return this; }
+    };
+  };
+
+  Headers.prototype.keys = function() {
+    var keys = Object.keys(this._map).sort();
+    var idx = 0;
+    return {
+      next: function() {
+        if (idx >= keys.length) return { done: true, value: undefined };
+        return { done: false, value: keys[idx++] };
+      },
+      [Symbol.iterator]: function() { return this; }
+    };
+  };
+
+  Headers.prototype.values = function() {
+    var keys = Object.keys(this._map).sort();
+    var map = this._map;
+    var idx = 0;
+    return {
+      next: function() {
+        if (idx >= keys.length) return { done: true, value: undefined };
+        return { done: false, value: map[keys[idx++]].join(', ') };
+      },
+      [Symbol.iterator]: function() { return this; }
+    };
+  };
+
+  Headers.prototype[Symbol.iterator] = Headers.prototype.entries;
+
+  // --- Response ---
+  function Response(body, init) {
+    if (init === undefined) init = {};
+    this.status = init.status !== undefined ? init.status : 200;
+    this.statusText = init.statusText !== undefined ? init.statusText : '';
+    this.headers = init.headers instanceof Headers ? init.headers : new Headers(init.headers);
+    this.body = body !== undefined && body !== null ? String(body) : '';
+    this.ok = this.status >= 200 && this.status <= 299;
+    this.url = '';
+    this.redirected = false;
+    this.type = 'basic';
+    this.bodyUsed = false;
+  }
+
+  Response.prototype.text = function() {
+    this.bodyUsed = true;
+    return Promise.resolve(this.body);
+  };
+
+  Response.prototype.json = function() {
+    this.bodyUsed = true;
+    try {
+      return Promise.resolve(JSON.parse(this.body));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+
+  Response.prototype.clone = function() {
+    var r = new Response(this.body, {
+      status: this.status,
+      statusText: this.statusText,
+      headers: new Headers(this.headers)
+    });
+    r.url = this.url;
+    r.redirected = this.redirected;
+    r.type = this.type;
+    return r;
+  };
+
+  Response.json = function(data, init) {
+    if (init === undefined) init = {};
+    var headers = init.headers instanceof Headers ? init.headers : new Headers(init.headers);
+    if (!headers.has('content-type')) {
+      headers.set('content-type', 'application/json');
+    }
+    return new Response(JSON.stringify(data), {
+      status: init.status !== undefined ? init.status : 200,
+      statusText: init.statusText || '',
+      headers: headers
+    });
+  };
+
+  Response.error = function() {
+    var r = new Response(null, { status: 0, statusText: '' });
+    r.type = 'error';
+    r.ok = false;
+    return r;
+  };
+
+  Response.redirect = function(url, status) {
+    if (status === undefined) status = 302;
+    var r = new Response(null, {
+      status: status,
+      statusText: '',
+      headers: new Headers({ location: String(url) })
+    });
+    r.redirected = true;
+    return r;
+  };
+
+  // --- Request ---
+  function Request(input, init) {
+    if (init === undefined) init = {};
+    if (input instanceof Request) {
+      this.url = input.url;
+      this.method = input.method;
+      this.headers = new Headers(input.headers);
+      this.body = input.body;
+    } else {
+      this.url = String(input);
+      this.method = 'GET';
+      this.headers = new Headers();
+      this.body = null;
+    }
+    if (init.method !== undefined) this.method = String(init.method).toUpperCase();
+    if (init.headers !== undefined) this.headers = init.headers instanceof Headers ? init.headers : new Headers(init.headers);
+    if (init.body !== undefined) this.body = init.body !== null ? String(init.body) : null;
+  }
+
+  Request.prototype.clone = function() {
+    return new Request(this);
+  };
+
+  // --- Assign to globalThis ---
+  globalThis.URLSearchParams = URLSearchParams;
+  globalThis.URL = URL;
+  globalThis.Headers = Headers;
+  globalThis.Response = Response;
+  globalThis.Request = Request;
+
+  // --- Wrap native fetch ---
+  var _nativeFetch = globalThis[Symbol.for('jb:fetch')];
+  globalThis.fetch = function fetch(input, init) {
+    try {
+      var url, method, headers, body;
+
+      if (input instanceof Request) {
+        url = input.url;
+        method = input.method;
+        headers = {};
+        input.headers.forEach(function(v, k) { headers[k] = v; });
+        body = input.body;
+      } else {
+        url = String(input);
+        method = undefined;
+        headers = undefined;
+        body = undefined;
+      }
+
+      if (init) {
+        if (init.method !== undefined) method = String(init.method).toUpperCase();
+        if (init.headers !== undefined) {
+          var h = init.headers instanceof Headers ? init.headers : new Headers(init.headers);
+          headers = {};
+          h.forEach(function(v, k) { headers[k] = v; });
+        }
+        if (init.body !== undefined) body = init.body !== null ? String(init.body) : undefined;
+      }
+
+      var opts = Object.create(null);
+      if (method) opts.method = method;
+      if (headers) opts.headers = headers;
+      if (body) opts.body = body;
+
+      var raw = _nativeFetch(url, opts);
+
+      var respHeaders = new Headers(raw.headers || {});
+      var response = new Response(raw.body, {
+        status: raw.status,
+        statusText: raw.statusText || '',
+        headers: respHeaders
+      });
+      response.url = raw.url || url;
+
+      return Promise.resolve(response);
+    } catch (e) {
+      return Promise.reject(new TypeError(e.message || 'fetch failed'));
+    }
+  };
+})();
+`;var we=`
+var EventEmitter = (function() {
+  function EE() {
+    this._events = {};
+    this._maxListeners = 10;
+  }
+  EE.prototype.on = function(event, listener) {
+    if (!this._events[event]) this._events[event] = [];
+    this._events[event].push(listener);
+    return this;
+  };
+  EE.prototype.addListener = EE.prototype.on;
+  EE.prototype.once = function(event, listener) {
+    var self = this;
+    function wrapper() {
+      self.removeListener(event, wrapper);
+      listener.apply(this, arguments);
+    }
+    wrapper._original = listener;
+    return this.on(event, wrapper);
+  };
+  EE.prototype.off = function(event, listener) {
+    return this.removeListener(event, listener);
+  };
+  EE.prototype.removeListener = function(event, listener) {
+    var list = this._events[event];
+    if (list) {
+      this._events[event] = list.filter(function(fn) {
+        return fn !== listener && fn._original !== listener;
+      });
+    }
+    return this;
+  };
+  EE.prototype.removeAllListeners = function(event) {
+    if (event) delete this._events[event];
+    else this._events = {};
+    return this;
+  };
+  EE.prototype.emit = function(event) {
+    var list = this._events[event];
+    if (!list || list.length === 0) return false;
+    var args = Array.prototype.slice.call(arguments, 1);
+    var fns = list.slice();
+    for (var i = 0; i < fns.length; i++) fns[i].apply(this, args);
+    return true;
+  };
+  EE.prototype.listeners = function(event) {
+    return (this._events[event] || []).slice();
+  };
+  EE.prototype.listenerCount = function(event) {
+    return (this._events[event] || []).length;
+  };
+  EE.prototype.setMaxListeners = function(n) {
+    this._maxListeners = n;
+    return this;
+  };
+  EE.prototype.eventNames = function() {
+    return Object.keys(this._events);
+  };
+  EE.prototype.prependListener = function(event, listener) {
+    if (!this._events[event]) this._events[event] = [];
+    this._events[event].unshift(listener);
+    return this;
+  };
+  return EE;
+})();
+globalThis[Symbol.for('jb:events')] = { EventEmitter: EventEmitter };
+`,xe=`
+var _os = {
+  platform: function() { return globalThis.process.platform; },
+  arch: function() { return globalThis.process.arch; },
+  homedir: function() { return '/home/user'; },
+  tmpdir: function() { return '/tmp'; },
+  type: function() { return 'Linux'; },
+  hostname: function() { return 'sandbox'; },
+  EOL: '\\n',
+  cpus: function() { return []; },
+  totalmem: function() { return 0; },
+  freemem: function() { return 0; },
+  endianness: function() { return 'LE'; }
+};
+globalThis[Symbol.for('jb:os')] = _os;
+`,Ee=`
+var _urlMod = {
+  URL: globalThis.URL,
+  URLSearchParams: globalThis.URLSearchParams,
+  parse: function(urlStr) {
+    try {
+      var u = new URL(urlStr);
+      return {
+        protocol: u.protocol, host: u.host, hostname: u.hostname,
+        port: u.port, pathname: u.pathname, search: u.search,
+        hash: u.hash, href: u.href, path: u.pathname + u.search
+      };
+    } catch(e) {
+      return {
+        protocol: null, host: null, hostname: null, port: null,
+        pathname: urlStr, search: '', hash: '', href: urlStr, path: urlStr
+      };
+    }
+  },
+  format: function(obj) {
+    if (typeof obj === 'string') return obj;
+    if (obj instanceof URL) return obj.href;
+    var auth = obj.auth ? obj.auth + '@' : '';
+    var host = obj.host || ((obj.hostname || '') + (obj.port ? ':' + obj.port : ''));
+    return (obj.protocol ? obj.protocol + '//' : '') + auth + host +
+      (obj.pathname || '/') + (obj.search || '') + (obj.hash || '');
+  }
+};
+globalThis[Symbol.for('jb:url')] = _urlMod;
+`,je=`
+var _deepEqual = function(a, b) {
+  if (a === b) return true;
+  if (a === null || b === null || typeof a !== 'object' || typeof b !== 'object') return false;
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  var ka = Object.keys(a), kb = Object.keys(b);
+  if (ka.length !== kb.length) return false;
+  for (var i = 0; i < ka.length; i++) {
+    if (!_deepEqual(a[ka[i]], b[ka[i]])) return false;
+  }
+  return true;
+};
+var _assert = function(val, msg) {
+  if (!val) throw new Error(msg || 'AssertionError: expected truthy value');
+};
+_assert.ok = _assert;
+_assert.equal = function(a, b, msg) {
+  if (a != b) throw new Error(msg || 'AssertionError: ' + a + ' != ' + b);
+};
+_assert.notEqual = function(a, b, msg) {
+  if (a == b) throw new Error(msg || 'AssertionError: ' + a + ' == ' + b);
+};
+_assert.strictEqual = function(a, b, msg) {
+  if (a !== b) throw new Error(msg || 'AssertionError: ' + a + ' !== ' + b);
+};
+_assert.notStrictEqual = function(a, b, msg) {
+  if (a === b) throw new Error(msg || 'AssertionError: ' + a + ' === ' + b);
+};
+_assert.deepEqual = function(a, b, msg) {
+  if (!_deepEqual(a, b)) throw new Error(msg || 'AssertionError: objects not deep equal');
+};
+_assert.deepStrictEqual = _assert.deepEqual;
+_assert.notDeepEqual = function(a, b, msg) {
+  if (_deepEqual(a, b)) throw new Error(msg || 'AssertionError: objects are deep equal');
+};
+_assert.throws = function(fn, expected, msg) {
+  var threw = false;
+  try { fn(); } catch(e) {
+    threw = true;
+    if (expected instanceof RegExp && !expected.test(e.message))
+      throw new Error(msg || 'AssertionError: error message did not match');
+  }
+  if (!threw) throw new Error(msg || 'AssertionError: function did not throw');
+};
+_assert.doesNotThrow = function(fn, msg) {
+  // @banned-pattern-ignore: sandbox-internal assertion helper; e.message is from user code inside QuickJS, not host details
+  try { fn(); } catch(e) {
+    throw new Error(msg || 'AssertionError: function threw: ' + e.message);
+  }
+};
+_assert.fail = function(msg) {
+  throw new Error(msg || 'AssertionError: assert.fail()');
+};
+globalThis[Symbol.for('jb:assert')] = _assert;
+`,Re=`
+var _util = {
+  format: function() {
+    var args = Array.prototype.slice.call(arguments);
+    if (args.length === 0) return '';
+    var fmt = args[0];
+    if (typeof fmt !== 'string') {
+      return args.map(function(a) {
+        return typeof a === 'string' ? a : JSON.stringify(a);
+      }).join(' ');
+    }
+    var i = 1;
+    var str = fmt.replace(/%[sdjifoO%]/g, function(m) {
+      if (m === '%%') return '%';
+      if (i >= args.length) return m;
+      var v = args[i++];
+      if (m === '%s') return String(v);
+      if (m === '%d') return Number(v).toString();
+      if (m === '%i') { var n = Number(v); return (isNaN(n) ? 'NaN' : Math.trunc(n)).toString(); }
+      if (m === '%j') return JSON.stringify(v);
+      if (m === '%f') return parseFloat(v).toString();
+      if (m === '%o' || m === '%O') return JSON.stringify(v);
+      return m;
+    });
+    while (i < args.length) {
+      str += ' ' + (typeof args[i] === 'string' ? args[i] : JSON.stringify(args[i]));
+      i++;
+    }
+    return str;
+  },
+  inspect: function(obj, opts) {
+    if (obj === null) return 'null';
+    if (obj === undefined) return 'undefined';
+    if (typeof obj === 'string') return "'" + obj + "'";
+    if (typeof obj === 'function') return '[Function: ' + (obj.name || 'anonymous') + ']';
+    var seen = [];
+    try {
+      return JSON.stringify(obj, function(key, val) {
+        if (typeof val === 'object' && val !== null) {
+          if (seen.indexOf(val) !== -1) return '[Circular]';
+          seen.push(val);
+        }
+        return val;
+      });
+    } catch(e) { return String(obj); }
+  },
+  promisify: function(fn) {
+    return function() {
+      var args = Array.prototype.slice.call(arguments);
+      return new Promise(function(resolve, reject) {
+        args.push(function(err, val) { if (err) reject(err); else resolve(val); });
+        fn.apply(null, args);
+      });
+    };
+  },
+  types: {
+    isDate: function(v) { return v instanceof Date; },
+    isRegExp: function(v) { return v instanceof RegExp; },
+    isArray: function(v) { return Array.isArray(v); },
+    isMap: function(v) { return typeof Map !== 'undefined' && v instanceof Map; },
+    isSet: function(v) { return typeof Set !== 'undefined' && v instanceof Set; }
+  },
+  inherits: function(ctor, superCtor) {
+    ctor.prototype = Object.create(superCtor.prototype);
+    ctor.prototype.constructor = ctor;
+  }
+};
+globalThis[Symbol.for('jb:util')] = _util;
+`,Ae=`
+function _utf8Encode(str) {
+  var bytes = [];
+  for (var i = 0; i < str.length; i++) {
+    var c = str.charCodeAt(i);
+    if (c < 0x80) {
+      bytes.push(c);
+    } else if (c < 0x800) {
+      bytes.push(0xC0 | (c >> 6), 0x80 | (c & 0x3F));
+    } else if (c >= 0xD800 && c <= 0xDBFF && i + 1 < str.length) {
+      var lo = str.charCodeAt(++i);
+      var cp = ((c - 0xD800) * 0x400) + (lo - 0xDC00) + 0x10000;
+      bytes.push(0xF0 | (cp >> 18), 0x80 | ((cp >> 12) & 0x3F), 0x80 | ((cp >> 6) & 0x3F), 0x80 | (cp & 0x3F));
+    } else {
+      bytes.push(0xE0 | (c >> 12), 0x80 | ((c >> 6) & 0x3F), 0x80 | (c & 0x3F));
+    }
+  }
+  return bytes;
+}
+function _utf8Decode(bytes) {
+  var str = '';
+  var i = 0;
+  while (i < bytes.length) {
+    var b = bytes[i];
+    if (b < 0x80) { str += String.fromCharCode(b); i++; }
+    else if ((b & 0xE0) === 0xC0) { str += String.fromCharCode(((b & 0x1F) << 6) | (bytes[i+1] & 0x3F)); i += 2; }
+    else if ((b & 0xF0) === 0xE0) { str += String.fromCharCode(((b & 0x0F) << 12) | ((bytes[i+1] & 0x3F) << 6) | (bytes[i+2] & 0x3F)); i += 3; }
+    else if ((b & 0xF8) === 0xF0) { var cp = ((b & 0x07) << 18) | ((bytes[i+1] & 0x3F) << 12) | ((bytes[i+2] & 0x3F) << 6) | (bytes[i+3] & 0x3F); cp -= 0x10000; str += String.fromCharCode((cp >> 10) + 0xD800, (cp & 0x3FF) + 0xDC00); i += 4; }
+    else { i++; }
+  }
+  return str;
+}
+// _utf8Encode/_utf8Decode are IIFE-local vars, available to all module shims
+// IMPORTANT: round-trip tests (encode then decode) mask broken encodings
+// because both sides become no-ops. Encoding tests MUST assert the encoded
+// constant directly.
+function _normEnc(enc) {
+  if (enc === undefined || enc === null) return 'utf8';
+  var e = String(enc).toLowerCase();
+  if (e === 'utf8' || e === 'utf-8') return 'utf8';
+  if (e === 'utf16le' || e === 'utf-16le' || e === 'ucs2' || e === 'ucs-2') return 'utf16le';
+  if (e === 'latin1' || e === 'binary') return 'latin1';
+  if (e === 'ascii') return 'ascii';
+  if (e === 'base64') return 'base64';
+  if (e === 'base64url') return 'base64url';
+  if (e === 'hex') return 'hex';
+  return undefined;
+}
+function _badEnc(enc) {
+  throw new TypeError("Unknown encoding: " + enc);
+}
+var _HEX = '0123456789abcdef';
+function _hexEncode(bytes) {
+  var s = '';
+  for (var i = 0; i < bytes.length; i++) {
+    var b = bytes[i] & 0xff;
+    s += _HEX.charAt(b >> 4) + _HEX.charAt(b & 0x0f);
+  }
+  return s;
+}
+function _hexDecode(str) {
+  var out = [];
+  for (var i = 0; i + 1 < str.length; i += 2) {
+    var hi = _hexVal(str.charCodeAt(i));
+    var lo = _hexVal(str.charCodeAt(i + 1));
+    if (hi < 0 || lo < 0) break;
+    out.push((hi << 4) | lo);
+  }
+  return out;
+}
+function _hexVal(c) {
+  if (c >= 48 && c <= 57) return c - 48;
+  if (c >= 97 && c <= 102) return c - 87;
+  if (c >= 65 && c <= 70) return c - 55;
+  return -1;
+}
+function _rawEncode(str) {
+  var out = new Array(str.length);
+  for (var i = 0; i < str.length; i++) out[i] = str.charCodeAt(i) & 0xff;
+  return out;
+}
+function _latin1Decode(bytes) {
+  var s = '';
+  for (var i = 0; i < bytes.length; i++) s += String.fromCharCode(bytes[i] & 0xff);
+  return s;
+}
+function _asciiDecode(bytes) {
+  var s = '';
+  for (var i = 0; i < bytes.length; i++) s += String.fromCharCode(bytes[i] & 0x7f);
+  return s;
+}
+function _utf16leEncode(str) {
+  var out = new Array(str.length * 2);
+  for (var i = 0; i < str.length; i++) {
+    var c = str.charCodeAt(i);
+    out[i * 2] = c & 0xff;
+    out[i * 2 + 1] = (c >> 8) & 0xff;
+  }
+  return out;
+}
+function _utf16leDecode(bytes) {
+  var s = '';
+  var end = bytes.length & ~1;
+  for (var i = 0; i < end; i += 2) {
+    s += String.fromCharCode(bytes[i] | (bytes[i + 1] << 8));
+  }
+  return s;
+}
+var _B64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+var _B64DEC = null;
+function _b64DecTable() {
+  if (_B64DEC) return _B64DEC;
+  var t = new Array(256);
+  for (var i = 0; i < 256; i++) t[i] = -1;
+  for (var j = 0; j < 64; j++) t[_B64.charCodeAt(j)] = j;
+  t[45] = 62;
+  t[95] = 63;
+  _B64DEC = t;
+  return t;
+}
+function _b64Encode(bytes) {
+  var s = '';
+  var i = 0, len = bytes.length;
+  while (i + 2 < len) {
+    var n = (bytes[i] << 16) | (bytes[i + 1] << 8) | bytes[i + 2];
+    s += _B64.charAt((n >> 18) & 63) + _B64.charAt((n >> 12) & 63)
+       + _B64.charAt((n >> 6) & 63)  + _B64.charAt(n & 63);
+    i += 3;
+  }
+  var rem = len - i;
+  if (rem === 1) {
+    var n1 = bytes[i] << 16;
+    s += _B64.charAt((n1 >> 18) & 63) + _B64.charAt((n1 >> 12) & 63) + '==';
+  } else if (rem === 2) {
+    var n2 = (bytes[i] << 16) | (bytes[i + 1] << 8);
+    s += _B64.charAt((n2 >> 18) & 63) + _B64.charAt((n2 >> 12) & 63)
+       + _B64.charAt((n2 >> 6) & 63) + '=';
+  }
+  return s;
+}
+function _b64UrlEncode(bytes) {
+  var s = _b64Encode(bytes);
+  return s.replace(/=+$/, '').replace(/\\+/g, '-').replace(/\\//g, '_');
+}
+function _b64Decode(str) {
+  var t = _b64DecTable();
+  var out = [];
+  var buf = 0, bits = 0;
+  for (var i = 0; i < str.length; i++) {
+    var c = str.charCodeAt(i);
+    if (c === 61) break;
+    var v = c < 256 ? t[c] : -1;
+    if (v < 0) continue;
+    buf = (buf << 6) | v;
+    bits += 6;
+    if (bits >= 8) {
+      bits -= 8;
+      out.push((buf >> bits) & 0xff);
+    }
+  }
+  return out;
+}
+
+function Buffer(arg) {
+  if (typeof arg === 'number') {
+    this._data = new Uint8Array(arg);
+  } else if (arg instanceof ArrayBuffer) {
+    this._data = new Uint8Array(arg);
+  } else if (arg instanceof Uint8Array) {
+    this._data = new Uint8Array(arg);
+  } else if (Array.isArray(arg)) {
+    this._data = new Uint8Array(arg);
+  } else {
+    this._data = new Uint8Array(0);
+  }
+  this.length = this._data.length;
+}
+Buffer.from = function(data, encoding) {
+  if (typeof data === 'string') {
+    var enc = _normEnc(encoding);
+    if (enc === undefined) _badEnc(encoding);
+    if (enc === 'utf8')      return new Buffer(_utf8Encode(data));
+    if (enc === 'utf16le')   return new Buffer(_utf16leEncode(data));
+    if (enc === 'latin1')    return new Buffer(_rawEncode(data));
+    if (enc === 'ascii')     return new Buffer(_rawEncode(data));
+    if (enc === 'hex')       return new Buffer(_hexDecode(data));
+    if (enc === 'base64' || enc === 'base64url') return new Buffer(_b64Decode(data));
+  }
+  if (data instanceof ArrayBuffer) {
+    var off = typeof encoding === 'number' ? encoding : 0;
+    var len = arguments.length > 2 ? arguments[2] : undefined;
+    var view = len === undefined ? new Uint8Array(data, off) : new Uint8Array(data, off, len);
+    var buf = Object.create(Buffer.prototype);
+    buf._data = view;
+    buf.length = view.length;
+    return buf;
+  }
+  if (data instanceof Uint8Array)  return new Buffer(data);
+  if (Array.isArray(data))         return new Buffer(data);
+  if (data && data._data)          return new Buffer(data._data.slice());
+  return new Buffer(0);
+};
+Buffer.alloc = function(size, fill) {
+  var buf = new Buffer(size);
+  if (fill !== undefined) {
+    var fillByte = typeof fill === 'number' ? fill : 0;
+    buf._data.fill(fillByte);
+  }
+  return buf;
+};
+Buffer.allocUnsafe = Buffer.alloc;
+Buffer.isBuffer = function(obj) { return obj instanceof Buffer; };
+Buffer.concat = function(list, totalLength) {
+  if (!totalLength) {
+    totalLength = 0;
+    for (var i = 0; i < list.length; i++) totalLength += list[i].length;
+  }
+  var result = new Uint8Array(totalLength);
+  var offset = 0;
+  for (var i = 0; i < list.length; i++) {
+    result.set(list[i]._data, offset);
+    offset += list[i].length;
+  }
+  return new Buffer(result);
+};
+Buffer.byteLength = function(value, encoding) {
+  if (typeof value !== 'string') {
+    if (value && value._data) return value._data.length;
+    if (value instanceof Uint8Array || value instanceof ArrayBuffer) {
+      return value.byteLength;
+    }
+    throw new TypeError('The "string" argument must be of type string or an instance of Buffer or ArrayBuffer. Received type ' + typeof value + ' (' + value + ')');
+  }
+  var enc = _normEnc(encoding);
+  if (enc === undefined) _badEnc(encoding);
+  if (enc === 'utf8')      return _utf8Encode(value).length;
+  if (enc === 'utf16le')   return value.length * 2;
+  if (enc === 'latin1' || enc === 'ascii') return value.length;
+  if (enc === 'hex')       return (value.length / 2) | 0;
+  if (enc === 'base64' || enc === 'base64url') {
+    var clean = value.replace(/[^A-Za-z0-9+/=_-]/g, '').replace(/=+$/, '');
+    return Math.floor(clean.length * 3 / 4);
+  }
+};
+Buffer.prototype.toString = function(encoding, start, end) {
+  var bytes = this._data;
+  if (start !== undefined || end !== undefined) {
+    var len = bytes.length;
+    var s = start === undefined ? 0 : (start < 0 ? 0 : (start > len ? len : start | 0));
+    var e = end === undefined ? len : (end < 0 ? 0 : (end > len ? len : end | 0));
+    bytes = e <= s ? bytes.subarray(0, 0) : bytes.subarray(s, e);
+  }
+  var enc = _normEnc(encoding);
+  if (enc === undefined) _badEnc(encoding);
+  if (enc === 'utf8')      return _utf8Decode(bytes);
+  if (enc === 'utf16le')   return _utf16leDecode(bytes);
+  if (enc === 'latin1')    return _latin1Decode(bytes);
+  if (enc === 'ascii')     return _asciiDecode(bytes);
+  if (enc === 'hex')       return _hexEncode(bytes);
+  if (enc === 'base64')    return _b64Encode(bytes);
+  if (enc === 'base64url') return _b64UrlEncode(bytes);
+};
+Buffer.prototype.toJSON = function() {
+  return { type: 'Buffer', data: Array.from(this._data) };
+};
+Buffer.prototype.slice = function(start, end) {
+  return new Buffer(this._data.slice(start, end));
+};
+Buffer.prototype.copy = function(target, targetStart, sourceStart, sourceEnd) {
+  targetStart = targetStart || 0;
+  sourceStart = sourceStart || 0;
+  sourceEnd = sourceEnd || this.length;
+  var sub = this._data.subarray(sourceStart, sourceEnd);
+  target._data.set(sub, targetStart);
+  return sub.length;
+};
+Buffer.prototype.write = function(str, offset, length, encoding) {
+  if (typeof offset === 'string') { encoding = offset; offset = 0; length = undefined; }
+  else if (typeof length === 'string') { encoding = length; length = undefined; }
+  offset = offset | 0;
+  if (offset < 0 || offset > this._data.length) {
+    throw new RangeError('The value of "offset" is out of range. It must be >= 0 && <= ' + this._data.length + '. Received ' + offset);
+  }
+  var enc = _normEnc(encoding);
+  if (enc === undefined) _badEnc(encoding);
+  var bytes;
+  if (enc === 'utf8')         bytes = _utf8Encode(str);
+  else if (enc === 'utf16le') bytes = _utf16leEncode(str);
+  else if (enc === 'latin1')  bytes = _rawEncode(str);
+  else if (enc === 'ascii')   bytes = _rawEncode(str);
+  else if (enc === 'hex')     bytes = _hexDecode(str);
+  else                        bytes = _b64Decode(str);
+  var max = this._data.length - offset;
+  if (length !== undefined) {
+    length = length | 0;
+    if (length < 0 || length > this._data.length) {
+      throw new RangeError('The value of "length" is out of range. It must be >= 0 && <= ' + this._data.length + '. Received ' + length);
+    }
+  }
+  var write = Math.min(length === undefined ? max : length, bytes.length, max);
+  for (var i = 0; i < write; i++) this._data[offset + i] = bytes[i];
+  return write;
+};
+Buffer.prototype.fill = function(val, offset, end) {
+  this._data.fill(typeof val === 'number' ? val : 0, offset, end);
+  return this;
+};
+Buffer.prototype.equals = function(other) {
+  if (this.length !== other.length) return false;
+  for (var i = 0; i < this.length; i++) {
+    if (this._data[i] !== other._data[i]) return false;
+  }
+  return true;
+};
+Buffer.prototype.readUInt8 = function(offset) { return this._data[offset]; };
+Buffer.prototype.writeUInt8 = function(value, offset) { this._data[offset] = value; return offset + 1; };
+globalThis[Symbol.for('jb:buffer')] = { Buffer: Buffer };
+globalThis.Buffer = Buffer;
+`,Ue=`
+var _EE = globalThis[Symbol.for('jb:events')].EventEmitter;
+
+function Stream() { _EE.call(this); }
+Stream.prototype = Object.create(_EE.prototype);
+Stream.prototype.constructor = Stream;
+Stream.prototype.pipe = function(dest) {
+  this.on('data', function(chunk) { dest.write(chunk); });
+  this.on('end', function() { if (dest.end) dest.end(); });
+  return dest;
+};
+
+function Readable(opts) {
+  Stream.call(this);
+  this.readable = true;
+  this._readableState = { ended: false, buffer: [] };
+}
+Readable.prototype = Object.create(Stream.prototype);
+Readable.prototype.constructor = Readable;
+Readable.prototype.read = function() { return null; };
+Readable.prototype.push = function(chunk) {
+  if (chunk === null) { this._readableState.ended = true; this.emit('end'); return false; }
+  this.emit('data', chunk);
+  return true;
+};
+Readable.prototype.destroy = function() { this.emit('close'); return this; };
+
+function Writable(opts) {
+  Stream.call(this);
+  this.writable = true;
+  this._writableState = { ended: false };
+}
+Writable.prototype = Object.create(Stream.prototype);
+Writable.prototype.constructor = Writable;
+Writable.prototype.write = function(chunk) { return true; };
+Writable.prototype.end = function(chunk) {
+  if (chunk) this.write(chunk);
+  this._writableState.ended = true;
+  this.emit('finish');
+  return this;
+};
+Writable.prototype.destroy = function() { this.emit('close'); return this; };
+
+function Duplex(opts) {
+  Readable.call(this, opts);
+  Writable.call(this, opts);
+}
+Duplex.prototype = Object.create(Readable.prototype);
+var _wKeys = Object.keys(Writable.prototype);
+for (var _wi = 0; _wi < _wKeys.length; _wi++) {
+  if (!Duplex.prototype[_wKeys[_wi]]) Duplex.prototype[_wKeys[_wi]] = Writable.prototype[_wKeys[_wi]];
+}
+Duplex.prototype.constructor = Duplex;
+
+function Transform(opts) { Duplex.call(this, opts); }
+Transform.prototype = Object.create(Duplex.prototype);
+Transform.prototype.constructor = Transform;
+Transform.prototype._transform = function(chunk, encoding, cb) { if (cb) cb(null, chunk); };
+
+function PassThrough(opts) { Transform.call(this, opts); }
+PassThrough.prototype = Object.create(Transform.prototype);
+PassThrough.prototype.constructor = PassThrough;
+
+function pipeline() {
+  var streams = Array.prototype.slice.call(arguments);
+  var cb = typeof streams[streams.length - 1] === 'function' ? streams.pop() : null;
+  for (var i = 0; i < streams.length - 1; i++) streams[i].pipe(streams[i + 1]);
+  if (cb) {
+    var last = streams[streams.length - 1];
+    last.on('finish', function() { cb(null); });
+    last.on('error', function(e) { cb(e); });
+  }
+  return streams[streams.length - 1];
+}
+
+globalThis[Symbol.for('jb:stream')] = {
+  Stream: Stream, Readable: Readable, Writable: Writable,
+  Duplex: Duplex, Transform: Transform, PassThrough: PassThrough,
+  pipeline: pipeline
+};
+`,ke=`
+function StringDecoder(encoding) {
+  this.encoding = (encoding || 'utf-8').toLowerCase();
+  if (this.encoding === 'utf8') this.encoding = 'utf-8';
+}
+StringDecoder.prototype.write = function(buf) {
+  if (typeof buf === 'string') return buf;
+  var data = buf instanceof Uint8Array ? buf : (buf && buf._data ? buf._data : new Uint8Array(0));
+  return _utf8Decode(data);
+};
+StringDecoder.prototype.end = function(buf) {
+  if (buf) return this.write(buf);
+  return '';
+};
+globalThis[Symbol.for('jb:string_decoder')] = { StringDecoder: StringDecoder };
+`,Ce=`
+var _qs = {
+  parse: function(str, sep, eq) {
+    sep = sep || '&'; eq = eq || '=';
+    var result = Object.create(null);
+    if (!str || typeof str !== 'string') return result;
+    var pairs = str.split(sep);
+    for (var i = 0; i < pairs.length; i++) {
+      var idx = pairs[i].indexOf(eq);
+      var key, val;
+      if (idx >= 0) {
+        key = decodeURIComponent(pairs[i].slice(0, idx).replace(/\\+/g, ' '));
+        val = decodeURIComponent(pairs[i].slice(idx + 1).replace(/\\+/g, ' '));
+      } else {
+        key = decodeURIComponent(pairs[i].replace(/\\+/g, ' '));
+        val = '';
+      }
+      if (result[key] !== undefined) {
+        if (Array.isArray(result[key])) result[key].push(val);
+        else result[key] = [result[key], val];
+      } else {
+        result[key] = val;
+      }
+    }
+    return result;
+  },
+  stringify: function(obj, sep, eq) {
+    sep = sep || '&'; eq = eq || '=';
+    var pairs = [];
+    var keys = Object.keys(obj);
+    for (var i = 0; i < keys.length; i++) {
+      var key = keys[i];
+      var val = obj[key];
+      if (Array.isArray(val)) {
+        for (var j = 0; j < val.length; j++) {
+          pairs.push(encodeURIComponent(key) + eq + encodeURIComponent(val[j]));
+        }
+      } else {
+        pairs.push(encodeURIComponent(key) + eq + encodeURIComponent(val));
+      }
+    }
+    return pairs.join(sep);
+  },
+  escape: function(str) { return encodeURIComponent(str); },
+  unescape: function(str) { return decodeURIComponent(str); }
+};
+_qs.decode = _qs.parse;
+_qs.encode = _qs.stringify;
+globalThis[Symbol.for('jb:querystring')] = _qs;
+`,I=Object.assign(Object.create(null),{http:"Use fetch() for HTTP requests.",https:"Use fetch() for HTTP requests.",http2:"Use fetch() for HTTP requests.",net:"Network socket APIs are not supported.",tls:"Network socket APIs are not supported.",dgram:"Network socket APIs are not supported.",dns:"DNS APIs are not supported.",cluster:"Cluster APIs are not supported.",worker_threads:"Worker thread APIs are not supported.",vm:"VM APIs are not supported.",v8:"V8 APIs are not supported.",inspector:"Inspector APIs are not supported.",readline:"Readline APIs are not supported.",repl:"REPL APIs are not supported.",module:"Module APIs are not supported.",perf_hooks:"Performance hooks are not supported.",async_hooks:"Async hooks are not supported.",diagnostics_channel:"Diagnostics channel is not supported.",trace_events:"Trace events are not supported.",crypto:"Crypto APIs are not available in this sandbox.",zlib:"Compression APIs are not supported.",tty:"TTY APIs are not supported.",domain:"Domain APIs are not supported."});var Te=`
+(function() {
+  var sep = '/';
+  var delimiter = ':';
+
+  function normalize(p) {
+    if (p === '') return '.';
+    var isAbs = p.charCodeAt(0) === 47;
+    var trailingSlash = p.charCodeAt(p.length - 1) === 47;
+    var parts = p.split('/');
+    var out = [];
+    for (var i = 0; i < parts.length; i++) {
+      var seg = parts[i];
+      if (seg === '' || seg === '.') continue;
+      if (seg === '..') {
+        if (out.length > 0 && out[out.length - 1] !== '..') out.pop();
+        else if (!isAbs) out.push('..');
+      } else {
+        out.push(seg);
+      }
+    }
+    var result = out.join('/');
+    if (isAbs) result = '/' + result;
+    if (trailingSlash && result[result.length - 1] !== '/') result += '/';
+    return result || (isAbs ? '/' : '.');
+  }
+
+  function join() {
+    var joined = '';
+    for (var i = 0; i < arguments.length; i++) {
+      var arg = arguments[i];
+      if (typeof arg !== 'string') throw new TypeError('Path must be a string');
+      if (arg.length > 0) {
+        if (joined.length > 0) joined += '/' + arg;
+        else joined = arg;
+      }
+    }
+    if (joined.length === 0) return '.';
+    return normalize(joined);
+  }
+
+  function resolve() {
+    var resolved = '';
+    var resolvedAbsolute = false;
+    for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+      var path = i >= 0 ? arguments[i] : globalThis.process.cwd();
+      if (typeof path !== 'string') throw new TypeError('Path must be a string');
+      if (path.length === 0) continue;
+      if (resolved.length > 0) resolved = path + '/' + resolved;
+      else resolved = path;
+      resolvedAbsolute = path.charCodeAt(0) === 47;
+    }
+    resolved = normalize(resolved);
+    if (resolvedAbsolute) return '/' + resolved.replace(/^\\/+/, '');
+    return resolved.length > 0 ? resolved : '.';
+  }
+
+  function isAbsolute(p) {
+    return typeof p === 'string' && p.length > 0 && p.charCodeAt(0) === 47;
+  }
+
+  function dirname(p) {
+    if (p.length === 0) return '.';
+    var hasRoot = p.charCodeAt(0) === 47;
+    var end = -1;
+    for (var i = p.length - 1; i >= 1; i--) {
+      if (p.charCodeAt(i) === 47) { end = i; break; }
+    }
+    if (end === -1) return hasRoot ? '/' : '.';
+    if (hasRoot && end === 0) return '/';
+    return p.slice(0, end);
+  }
+
+  function basename(p, ext) {
+    var start = 0;
+    for (var i = p.length - 1; i >= 0; i--) {
+      if (p.charCodeAt(i) === 47) { start = i + 1; break; }
+    }
+    var base = p.slice(start);
+    if (ext && base.endsWith(ext)) {
+      base = base.slice(0, base.length - ext.length);
+    }
+    return base;
+  }
+
+  function extname(p) {
+    var startDot = -1;
+    var startPart = 0;
+    for (var i = p.length - 1; i >= 0; i--) {
+      var code = p.charCodeAt(i);
+      if (code === 47) { startPart = i + 1; break; }
+      if (code === 46 && startDot === -1) startDot = i;
+    }
+    if (startDot === -1 || startDot === startPart ||
+        (startDot === startPart + 1 && p.charCodeAt(startPart) === 46)) {
+      return '';
+    }
+    return p.slice(startDot);
+  }
+
+  function relative(from, to) {
+    if (from === to) return '';
+    from = resolve(from);
+    to = resolve(to);
+    if (from === to) return '';
+    var fromParts = from.split('/').filter(Boolean);
+    var toParts = to.split('/').filter(Boolean);
+    var common = 0;
+    var length = Math.min(fromParts.length, toParts.length);
+    for (var i = 0; i < length; i++) {
+      if (fromParts[i] !== toParts[i]) break;
+      common++;
+    }
+    var ups = [];
+    for (var i = common; i < fromParts.length; i++) ups.push('..');
+    return ups.concat(toParts.slice(common)).join('/') || '.';
+  }
+
+  function parse(p) {
+    var root = p.charCodeAt(0) === 47 ? '/' : '';
+    var dir = dirname(p);
+    var base = basename(p);
+    var ext = extname(p);
+    var name = ext ? base.slice(0, base.length - ext.length) : base;
+    return { root: root, dir: dir, base: base, ext: ext, name: name };
+  }
+
+  function format(obj) {
+    var dir = obj.dir || obj.root || '';
+    var base = obj.base || ((obj.name || '') + (obj.ext || ''));
+    if (!dir) return base;
+    if (dir === obj.root) return dir + base;
+    return dir + '/' + base;
+  }
+
+  var posix = { sep: sep, delimiter: delimiter, join: join, resolve: resolve, normalize: normalize, isAbsolute: isAbsolute, dirname: dirname, basename: basename, extname: extname, relative: relative, parse: parse, format: format };
+  posix.posix = posix;
+
+  globalThis[Symbol.for('jb:path')] = posix;
+})();
+`;var N=new et,$=[],K=!1,it=256*1024*1024,Le=32*1024*1024,x=2147483647,Pe=4096,ot=64*1024,at=8*1024,Ie=()=>typeof crypto<"u"&&crypto.randomUUID?crypto.randomUUID().replaceAll("-",""):`${Date.now().toString(36)}_${Math.random().toString(36).slice(2)}`,ut=()=>`__jbHost_${Ie()}`,q=class extends Error{},lt=Ae.replace("Buffer.prototype.toString = function(encoding, start, end) {","Object.defineProperty(Buffer.prototype, 'toString', { configurable: true, writable: true, value: function(encoding, start, end) {").replace(`};
+Buffer.prototype.toJSON = function() {`,`}});
+Buffer.prototype.toJSON = function() {`),ft=_e.replace("URLSearchParams.prototype.toString = function() {","Object.defineProperty(URLSearchParams.prototype, 'toString', { configurable: true, writable: true, value: function() {").replace(`  };
+
+  URLSearchParams.prototype.forEach`,`  }});
+
+  URLSearchParams.prototype.forEach`).replace("URL.prototype.toString = function() { return this.href; };","Object.defineProperty(URL.prototype, 'toString', { configurable: true, writable: true, value: function() { return this.href; } });"),Fe=Object.assign(Object.create(null),{assert:["ok","equal","notEqual","strictEqual","notStrictEqual","deepEqual","deepStrictEqual","notDeepEqual","throws","doesNotThrow","fail"],buffer:["Buffer"],child_process:["exec","execSync","spawnSync"],console:["log","error","warn"],events:["EventEmitter"],fs:["readFile","readFileSync","readFileBuffer","writeFile","writeFileSync","stat","statSync","lstat","lstatSync","readdir","readdirSync","mkdir","mkdirSync","rm","rmSync","exists","existsSync","appendFile","appendFileSync","symlink","symlinkSync","readlink","readlinkSync","chmod","chmodSync","realpath","realpathSync","rename","renameSync","copyFile","copyFileSync","unlink","unlinkSync","rmdir","rmdirSync","promises"],os:["platform","arch","homedir","tmpdir","type","hostname","EOL","cpus","totalmem","freemem","endianness"],path:["join","resolve","normalize","isAbsolute","dirname","basename","extname","relative","parse","format","sep","delimiter","posix"],process:["argv","cwd","exit","env","platform","arch","versions","version"],querystring:["parse","stringify","escape","unescape","decode","encode"],stream:["Stream","Readable","Writable","Duplex","Transform","PassThrough","pipeline"],string_decoder:["StringDecoder"],url:["URL","URLSearchParams","parse","format"],util:["format","inspect","promisify","types","inherits"]}),ct=r=>r==="fs"||r==="process"||r==="console"?`globalThis.${r}`:r==="child_process"?"globalThis[Symbol.for('jb:child_process')]":`globalThis[Symbol.for('jb:${r}')]`,dt=r=>{let e=Fe[r];if(e===void 0){let n=I[r];if(n!==void 0)return`throw new Error(${JSON.stringify(`Module '${r}' is not available in the js-exec sandbox. ${n} Run 'js-exec --help' for available modules.`)});`;throw new Error(`Cannot find module '${r}'.`)}return[`const value = ${ct(r)};`,...e.map(n=>n==="default"?"":`export const ${n} = value.${n};`),"export default value;"].join(`
+`)},pt=(r,e)=>{let s=(e.startsWith("/")?e:`${r}/${e}`).split("/"),n=[];for(let o of s)!o||o==="."||(o===".."?n.pop():n.push(o));return`/${n.join("/")}`},O=(r,e)=>{if(e<=0)return"";let s=m.from(r);if(s.byteLength<=e)return r;let n=e;for(;n>0&&(s[n]&192)===128;)n--;return s.subarray(0,n).toString("utf8")},Be=r=>{if(r.length===0)return;let e=0;for(let s=0;s<r.length;s++){let n=r.charCodeAt(s)-48;if(n<0||n>9||(e=e*10+n,!Number.isSafeInteger(e)))return}return e},Me=r=>{let e=r.lastIndexOf(":");if(e<=0)return;let s=r.lastIndexOf(":",e-1);if(s<=0)return;let n=Be(r.slice(s+1,e)),o=Be(r.slice(e+1)),u=r.slice(0,s);if(!(n===void 0||o===void 0||u.length===0))return{column:o,file:u,line:n}},Q=r=>{for(let e of r.slice(0,ot).split(`
+`)){if(e.length>at)continue;let s=e.trimStart();if(!s.startsWith("at "))continue;let n=s.slice(3);if(n.endsWith(")")){let u=n.lastIndexOf(" (");if(u>0){let l=Me(n.slice(u+2,-1));if(l!==void 0)return{...l,functionName:n.slice(0,u)}}}let o=Me(n);if(o!==void 0)return o}},ht=(r,e)=>{let s=2;for(let n=0;n<r.length;n++){let o=r.charCodeAt(n);if(o===34||o===92)s+=2;else if(o===8||o===9||o===10||o===12||o===13)s+=2;else if(o<32)s+=6;else if(o<128)s+=1;else if(o<2048)s+=2;else if(o>=55296&&o<=56319){let u=r.charCodeAt(n+1);u>=56320&&u<=57343?(s+=4,n+=1):s+=6}else o>=56320&&o<=57343?s+=6:s+=3;if(s>e)return e+1}return s},mt=(r,e,s,n)=>{let o=2,u=c=>(o+=ht(c,Math.max(0,n-o)),o<=n),l=!0;for(let[c,y]of Object.entries(r))if(l||(o+=1),l=!1,!u(c)||(o+=1,!u(y)))return n+1;o+=2,l=!0;for(let c of e)if(l||(o+=1),l=!1,!u(c))return n+1;return u(s)?o:n+1},yt=(r,e,s)=>{let n=S(T(r));if(/^[A-Za-z_$][\w$]* is not defined$/u.test(n)&&(n=`'${n.slice(0,n.indexOf(" "))}'${n.slice(n.indexOf(" "))}`),r instanceof Error&&r.name==="SyntaxError"&&n==="Unexpected token '}'"&&(n="expecting ')'"),!(r instanceof Error)||r.stack===void 0)return n;let o=Q(r.stack);if(o===void 0)return n;let{column:u,file:l,functionName:c,line:y}=o;return(l==="run.js"||l==="<entry>")&&(l=e.scriptPath,y=Math.max(1,y-s),e.isModule||(c=e.scriptPath==="-c"?"<eval>":void 0)),r.name==="Error"?u+=5:r.name==="TypeError"&&(u+=1),`${c===void 0?`at ${l}:${y}:${u}`:`at ${c} (${l}:${y}:${u})`}: ${n}`},bt=(r,e,s,n,o)=>`
+(function() {
+  var host = globalThis[${JSON.stringify(o)}];
+  function unwrap(result) {
+    if (!result || result.ok !== true) {
+      var err = new Error(result && result.error || 'Host operation failed');
+      if (result && typeof result.code === 'string') err.code = result.code;
+      throw err;
+    }
+    return result.value;
+  }
+  function bytes(value) {
+    if (typeof value === 'string') return value;
+    var arr;
+    if (value && value._data instanceof Uint8Array) arr = value._data;
+    else if (value && Array.isArray(value._data)) arr = value._data;
+    else if (Array.isArray(value)) arr = value;
+    else if (value instanceof Uint8Array) arr = value;
+    else throw new TypeError('File data must be a string, Buffer, Uint8Array, or byte array');
+    // Latin-1 encode: one char per byte. chunks.join avoids O(n\xB2)
+    // string-concat copies that would stall on MB-scale payloads.
+    var chunks = [];
+    var CHUNK = 32768;
+    for (var i = 0; i < arr.length; i += CHUNK) {
+      chunks.push(String.fromCharCode.apply(null, Array.prototype.slice.call(arr, i, Math.min(i + CHUNK, arr.length))));
+    }
+    return chunks.join('');
+  }
+  // Write in small chunks WITHOUT holding the full latin1 string in
+  // scope \u2014 run's continuation serializes live bindings per sync host
+  // call, so a large string in scope would stall every chunk's bridge.
+  // Write in bridge-sized chunks. run's sync bridge stalls on
+  // cumulative payload > ~6MB, so keep chunks small and let each
+  // one go out of scope before the next call.
+  function writeChunked(path, data, append) {
+    var arr;
+    if (typeof data === 'string') arr = null;
+    else if (data && data._data instanceof Uint8Array) arr = data._data;
+    else if (data && Array.isArray(data._data)) arr = data._data;
+    else if (Array.isArray(data)) arr = data;
+    else if (data instanceof Uint8Array) arr = data;
+    else if (data instanceof Buffer) arr = data._data;
+    else throw new TypeError('File data must be a string, Buffer, Uint8Array, or byte array');
+    var BRIDGE_CHUNK = 4194304; // 4MB per bridge call \u2014 largest size that clears the sync bridge without stalling
+    var CC_CHUNK = 32768; // fromCharCode apply() arg limit
+    var offset = 0;
+    var first = !append;
+    var totalLen = arr ? arr.length : data.length;
+    while (offset < totalLen) {
+      var end = Math.min(offset + BRIDGE_CHUNK, totalLen);
+      var chunk;
+      if (arr) {
+        var parts = [];
+        for (var i = offset; i < end; i += CC_CHUNK) {
+          parts.push(String.fromCharCode.apply(null, Array.prototype.slice.call(arr, i, Math.min(i + CC_CHUNK, end))));
+        }
+        chunk = parts.join('');
+      } else {
+        chunk = data.substring(offset, end);
+      }
+      if (first) {
+        unwrap(host.fsWrite(path, chunk));
+        first = false;
+      } else {
+        unwrap(host.fsAppend(path, chunk));
+      }
+      offset = end;
+    }
+  }
+  function format(value) {
+    if (typeof Buffer === 'function' && value instanceof Buffer) return value.toString();
+    if (typeof value === 'string') return value;
+    if (value === undefined) return 'undefined';
+    try { return JSON.stringify(value); } catch (_) { return String(value); }
+  }
+
+  globalThis.env = ${r};
+  globalThis.process = {
+    argv: ${e},
+    cwd: function() { return ${s}; },
+    env: globalThis.env,
+    platform: 'linux',
+    arch: 'x64',
+    versions: { node: '22.0.0', quickjs: '2025' },
+    version: 'v22.0.0',
+    exit: function(code) { return host.exit(Number(code) || 0); }
+  };
+
+  ${lt}
+  var fs = {
+    readFileBuffer: function(path) {
+      var raw = unwrap(host.fsRead(path));
+      var data = new Uint8Array(raw.length);
+      for (var i = 0; i < raw.length; i++) data[i] = raw.charCodeAt(i) & 255;
+      return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+    },
+    readFileSync: function(path, opts) {
+      var raw = unwrap(host.fsRead(path));
+      var encoding = typeof opts === 'string' ? opts : opts && opts.encoding;
+      if (encoding === 'utf8' || encoding === 'utf-8') {
+        // The host returns latin1 (one char per byte). For text reads,
+        // return it directly \u2014 the per-char charCodeAt loop stalls on
+        // MB-scale payloads in QuickJS. Latin-1 and UTF-8 are identical
+        // for ASCII; for non-ASCII, the caller gets the raw bytes as
+        // latin1 chars (matching Node.js 'binary' encoding behavior).
+        return raw;
+      }
+      var buffer = Buffer.alloc(raw.length);
+      for (var i = 0; i < raw.length; i++) buffer._data[i] = raw.charCodeAt(i) & 255;
+      return buffer;
+    },
+    writeFileSync: function(path, data) {
+      writeChunked(path, data, false);
+    },
+    appendFileSync: function(path, data) {
+      writeChunked(path, data, true);
+    },
+    statSync: function(path) { return unwrap(host.fsStat(path, false)); },
+    lstatSync: function(path) { return unwrap(host.fsStat(path, true)); },
+    readdirSync: function(path) { return unwrap(host.fsReaddir(path)); },
+    mkdirSync: function(path, opts) { unwrap(host.fsMkdir(path, Boolean(opts && opts.recursive))); },
+    rmSync: function(path, opts) { unwrap(host.fsRm(path, Boolean(opts && opts.recursive), Boolean(opts && opts.force))); },
+    existsSync: function(path) { return unwrap(host.fsExists(path)); },
+    symlinkSync: function(target, path) { unwrap(host.fsSymlink(target, path)); },
+    readlinkSync: function(path) { return unwrap(host.fsReadlink(path)); },
+    chmodSync: function(path, mode) { unwrap(host.fsChmod(path, Number(mode))); },
+    realpathSync: function(path) { return unwrap(host.fsRealpath(path)); },
+    renameSync: function(from, to) { unwrap(host.fsRename(from, to)); },
+    copyFileSync: function(from, to) { unwrap(host.fsCopy(from, to)); }
+  };
+  fs.unlinkSync = fs.rmSync;
+  fs.rmdirSync = fs.rmSync;
+  function callbackUnsupported(name) {
+    return function() { throw new Error('fs.' + name + '() with callbacks is not supported. Use fs.' + name + 'Sync() or fs.promises.' + name + '() instead.'); };
+  }
+  var names = ['readFile','writeFile','appendFile','stat','lstat','readdir','mkdir','rm','symlink','readlink','chmod','realpath','rename','copyFile'];
+  for (var i = 0; i < names.length; i++) fs[names[i]] = callbackUnsupported(names[i]);
+  fs.exists = callbackUnsupported('exists');
+  fs.unlink = callbackUnsupported('unlink');
+  fs.rmdir = callbackUnsupported('rmdir');
+  fs.promises = {};
+  for (var i = 0; i < names.length; i++) (function(name) {
+    var sync = fs[name + 'Sync'];
+    fs.promises[name] = function() {
+      try { return Promise.resolve(sync.apply(fs, arguments)); }
+      catch (error) { return Promise.reject(error); }
+    };
+  })(names[i]);
+  fs.promises.unlink = fs.promises.rm;
+  fs.promises.rmdir = fs.promises.rm;
+  fs.promises.access = function(path) { return fs.existsSync(path) ? Promise.resolve() : Promise.reject(Object.assign(new Error('no such file or directory: ' + path), {code: 'ENOENT'})); };
+  globalThis.fs = fs;
+
+  ${Te}
+  ${we}
+  ${xe}
+  ${je}
+  ${Re}
+  ${Ue}
+  ${ke}
+  ${Ce}
+
+  var nativeFetch = function(url, opts) { return unwrap(host.fetch(String(url), opts)); };
+  globalThis[Symbol.for('jb:fetch')] = nativeFetch;
+  ${ft}
+  ${Ee}
+
+  var childProcess = {
+    exec: function(command, opts) { return unwrap(host.exec(String(command), opts && opts.stdin)); },
+    execSync: function(command, opts) {
+      var result = unwrap(host.exec(String(command), opts && opts.stdin));
+      if (result.exitCode !== 0) {
+        var error = new Error('Command failed: ' + command);
+        error.status = result.exitCode; error.stdout = result.stdout; error.stderr = result.stderr;
+        throw error;
+      }
+      return result.stdout;
+    },
+    spawnSync: function(command, args) {
+      var result = unwrap(host.execArgs(String(command), args || []));
+      return { stdout: result.stdout, stderr: result.stderr, status: result.exitCode };
+    }
+  };
+  globalThis[Symbol.for('jb:child_process')] = childProcess;
+
+  var modules = Object.create(null);
+  modules.fs = fs;
+  modules.path = globalThis[Symbol.for('jb:path')];
+  modules.child_process = childProcess;
+  modules.process = globalThis.process;
+  modules.console = globalThis.console;
+  modules.os = globalThis[Symbol.for('jb:os')];
+  modules.url = globalThis[Symbol.for('jb:url')];
+  modules.assert = globalThis[Symbol.for('jb:assert')];
+  modules.util = globalThis[Symbol.for('jb:util')];
+  modules.events = globalThis[Symbol.for('jb:events')];
+  modules.buffer = globalThis[Symbol.for('jb:buffer')];
+  modules.stream = globalThis[Symbol.for('jb:stream')];
+  modules.string_decoder = globalThis[Symbol.for('jb:string_decoder')];
+  modules.querystring = globalThis[Symbol.for('jb:querystring')];
+  var unsupported = ${JSON.stringify(I)};
+  globalThis.require = function(name) {
+    name = String(name); if (name.startsWith('node:')) name = name.slice(5);
+    if (Object.prototype.hasOwnProperty.call(modules, name)) return modules[name];
+    if (Object.prototype.hasOwnProperty.call(unsupported, name)) throw new Error("Module '" + name + "' is not available in the js-exec sandbox. " + unsupported[name] + " Run 'js-exec --help' for available modules.");
+    throw new Error("Cannot find module '" + name + "'. Run 'js-exec --help' for available modules.");
+  };
+  globalThis.require.resolve = function(name) { return name; };
+
+  console.log = function() { unwrap(host.stdout(Array.prototype.map.call(arguments, format).join(' ') + '\\n')); };
+  console.info = console.log;
+  console.debug = console.log;
+  console.error = function() { unwrap(host.stderr(Array.prototype.map.call(arguments, format).join(' ') + '\\n')); };
+  console.warn = console.error;
+
+  ${n?`globalThis.tools = (function makeProxy(path) {
+    return new Proxy(function(){}, {
+      get: function(_target, property) {
+        if (property === 'then' || typeof property === 'symbol') return undefined;
+        return makeProxy(path.concat([String(property)]));
+      },
+      apply: function(_target, _this, args) {
+        var argsJson = args.length ? JSON.stringify(args[0]) : '';
+        var value = unwrap(host.invokeTool(path.join('.'), argsJson || ''));
+        return value ? JSON.parse(value) : undefined;
+      }
+    });
+  })([]);`:""}
+})();
+`,X=()=>{if(K)return;let r=$.shift();if(r!==void 0){if(r.canceled){X();return}K=!0,r.start()}},gt=(r,e)=>{let s=w.bindCurrentContext(r);return new Promise((n,o)=>{let u={canceled:!1,start(){e?.removeEventListener("abort",l),(async()=>{try{n(await s())}catch(c){o(c)}finally{K=!1,X()}})()}},l=()=>{let c=$.indexOf(u);c!==-1&&($.splice(c,1),u.canceled=!0,e?.removeEventListener("abort",l),o(new q))};e?.addEventListener("abort",l,{once:!0}),$.push(u),e?.aborted?l():X()})},vt=r=>({isDirectory:r.isDirectory,isFile:r.isFile,isSymbolicLink:r.isSymbolicLink,mode:r.mode,mtime:r.mtime.toISOString(),size:r.size}),De=r=>({exitCode:r.exitCode,stderr:r.stderr,stdout:r.stdout}),St=(r,e,s)=>({exitCode:e,stderr:s<=0?r:O(r,s),stdout:""});async function _t(r,e,s,n,o){let u=Math.min(e.limits.maxWorkerMessageBytes,Le),l=Math.max(0,u-Pe),c=Math.max(0,Math.min(e.limits.maxWorkerMessageBytes,u-Pe,x)),y=ut(),U=`just-bash:bootstrap:${Ie()}`,f={exitCode:0,limitExceeded:!1,stderr:"",stdout:""},v,H,Z=r.bootstrapCode!==void 0&&r.bootstrapCode!=="",_=e.limits.maxOutputSize,k=0,ee=0,L=!1,P=new Map,te=!1,E=`JavaScript runtime exceeded the ${e.limits.maxJsBridgeRequests} bridge request limit.`,C=()=>ee>=e.limits.maxJsBridgeRequests?(L=!0,!1):(ee+=1,!0),j=t=>{if(_<=0){f.stderr+=t,k+=m.byteLength(t);return}let i=O(t,Math.max(0,_-k));f.stderr+=i,k+=m.byteLength(i)},re=()=>{te||(te=!0,f.exitCode=1,j(`js-exec: ${E}
+`))},ne=(t,i)=>{if(v!==void 0)return{error:"process.exit() already requested",ok:!1};if(!C())return{error:E,ok:!1};if(typeof i!="string")return{error:"Output must be a string",ok:!1};let a=k+m.byteLength(i);return _>0&&a>_?(f.limitExceeded=!0,f.exitCode=1,{error:"Output size limit exceeded",ok:!1}):(f[t]+=i,k=a,{ok:!0,value:void 0})},h=t=>e.fs.resolvePath(e.cwd,t),d=async(t,i=S)=>{if(v!==void 0)return{error:"process.exit() already requested",ok:!1};if(!C())return{error:E,ok:!1};try{return{ok:!0,value:await w.runUntrustedAsync(t)}}catch(a){let p=ge(a);return{ok:!1,error:i(T(a)),...p!==void 0&&{code:p}}}},J=t=>{if(typeof t=="string"){let i=new Uint8Array(t.length);for(let a=0;a<t.length;a++)i[a]=t.charCodeAt(a)&255;return i}throw new TypeError("File data must be a string, Buffer, Uint8Array, or byte array")},B=Se(e.env),se=[r.scriptPath,...r.scriptArgs],R=Math.min(e.limits.maxWorkerMessageBytes,x),M=m.byteLength(r.source),W=Math.max(0,R-M),qe=mt(B,se,e.cwd,W);if(M>R||qe>W)return f.exitCode=1,j(`js-exec: JavaScript runtime ${M>R?"source":"input"} exceeds the ${R} byte size limit.
+`),f;let ie=JSON.stringify(B),oe=JSON.stringify(se),ae=JSON.stringify(e.cwd),z=m.byteLength(ie)+m.byteLength(oe)+m.byteLength(ae);if(z>W)return f.exitCode=1,j(`js-exec: JavaScript runtime input exceeds the ${R} byte size limit.
+`),f;let He=w.runTrusted(()=>tt({syncHostFunctions:{[y]:{bootstrapError(t){throw Z?(H??=S(typeof t=="string"?t:"Bootstrap failed"),new Error("Bootstrap failed.")):new Error("Bootstrap phase has ended.")},bootstrapDone(){Z=!1},exit(t){throw C()?(v??=Number.isFinite(t)?Math.trunc(t):0,f.exitCode=v,new Error("Guest requested process exit.")):new Error(E)},fsRead:t=>d(async()=>{let i=h(t),a=await e.fs.readFileBuffer(i);if(a.byteLength>l)throw new Error(`File exceeds JavaScript bridge read limit (${l} bytes)`);return m.from(a).toString("latin1")}),fsWrite:(t,i)=>d(async()=>await e.fs.writeFile(h(t),J(i))),fsWriteStage:(t,i)=>d(async()=>{let a=h(t),p=P.get(a)??[];p.push(J(i)),P.set(a,p)}),fsWriteCommit:t=>d(async()=>{let i=h(t),a=P.get(i);if(P.delete(i),!a||a.length===0)throw new be("EINVAL",`fsWriteCommit without staged data: '${t}'`);let p=a.reduce((A,Ze)=>A+Ze.byteLength,0),b=new Uint8Array(p),g=0;for(let A of a)b.set(A,g),g+=A.byteLength;await e.fs.writeFile(i,b)}),fsAppend:(t,i)=>d(async()=>await e.fs.appendFile(h(t),J(i))),fsStat:(t,i)=>d(async()=>vt(await(i?e.fs.lstat(h(t)):e.fs.stat(h(t))))),fsReaddir:t=>d(async()=>await e.fs.readdir(h(t))),fsMkdir:(t,i)=>d(async()=>await e.fs.mkdir(h(t),{recursive:i})),fsRm:(t,i,a)=>d(async()=>await e.fs.rm(h(t),{force:a,recursive:i})),fsExists:t=>d(async()=>await e.fs.exists(h(t))),fsSymlink:(t,i)=>d(async()=>await e.fs.symlink(t,h(i))),fsReadlink:t=>d(async()=>await e.fs.readlink(h(t))),fsChmod:(t,i)=>d(async()=>await e.fs.chmod(h(t),i)),fsRealpath:t=>d(async()=>await e.fs.realpath(h(t))),fsRename:(t,i)=>d(async()=>await e.fs.mv(h(t),h(i))),fsCopy:(t,i)=>d(async()=>await e.fs.cp(h(t),h(i))),stdout:t=>ne("stdout",t),stderr:t=>ne("stderr",t),async fetch(t,i){return await d(async()=>{if(!e.fetch)throw new Error("Network access not configured. Enable network in Bash options.");let a=n===Number.POSITIVE_INFINITY?void 0:Math.max(0,n-Date.now()),p=await e.fetch(t,{method:i?.method,headers:i?.headers,body:i?.body,...a===void 0?{}:{timeoutMs:a},signal:F().abortSignal});return{body:m.from(p.body).toString("latin1"),headers:p.headers,status:p.status,statusText:p.statusText,url:p.url}})},async exec(t,i){return await d(async()=>{if(!e.exec)throw new Error("Command execution not available in this context.");let a={cwd:e.cwd,env:B,signal:F().abortSignal,stdin:i??""},p=await N.run(!0,()=>e.exec?.(t,a));return De(p)})},async execArgs(t,i){return await d(async()=>{if(!e.exec)throw new Error("Command execution not available in this context.");let a=await N.run(!0,()=>e.exec?.(ve([t]),{args:i.map(String),cwd:e.cwd,env:B,signal:F().abortSignal}));return De(a)})},async invokeTool(t,i){return await d(async()=>{if(!e.invokeTool)throw new Error(`Unknown tool: ${t}`);let{abortSignal:a}=F();return await w.runTrustedAsync(()=>e.invokeTool?.(t,i,a))},D)}}}})),ue=bt(ie,oe,ae,e.invokeTool!==void 0,y),G=r.bootstrapCode??"",le=G===""?`globalThis[${JSON.stringify(y)}].bootstrapDone();
+`:`try {
+  (function() {
+${G}
+  })();
+} catch (__jbBootstrapError) {
+  var __jbBootstrapMessage = 'Bootstrap failed';
+  try {
+    __jbBootstrapMessage = __jbBootstrapError && typeof __jbBootstrapError.message === 'string'
+      ? __jbBootstrapError.message
+      : String(__jbBootstrapError);
+  } catch (_) {}
+  globalThis[${JSON.stringify(y)}].bootstrapError(__jbBootstrapMessage);
+} finally {
+  globalThis[${JSON.stringify(y)}].bootstrapDone();
+}
+`,V=`${ue}
+${le}`,Je={identity:"just-bash-js-exec-v1",normalize(t,i){let a=t.startsWith("node:")?t.slice(5):t;if(v!==void 0)throw new Error("process.exit() already requested");if(t===U)return t;if(!C())throw new Error(E);if(Fe[a]!==void 0||I[a]!==void 0)return`just-bash:builtin:${a}`;if(!t.startsWith(".")&&!t.startsWith("/"))return`just-bash:missing:${t}`;let p=i==="<entry>"||i.startsWith("just-bash:")?r.scriptPath:i,b=p.lastIndexOf("/"),g=b<0?e.cwd:b===0?"/":p.slice(0,b);return pt(g,t)},async load(t){if(v!==void 0)throw new Error("process.exit() already requested");if(t===U)return V;if(!C())throw new Error(E);if(t.startsWith("just-bash:builtin:"))return dt(t.slice(18));if(t.startsWith("just-bash:missing:")){let i=t.slice(18);return`throw new Error(${JSON.stringify(`Cannot find module '${i}': not found. Run 'js-exec --help' for available modules.`)});`}try{return await w.runUntrustedAsync(async()=>{if((await e.fs.stat(t)).size>c)throw new Error(`Module exceeds JavaScript source limit (${c} bytes)`);let a=await e.fs.readFile(t);if(m.byteLength(a)>c)throw new Error(`Module exceeds JavaScript source limit (${c} bytes)`);return a})}catch(i){return`throw new Error(${JSON.stringify(S(T(i)))});`}}},fe=r.isModule?`import ${JSON.stringify(U)};
+`:`${ue}
+${le}`,ce=`${fe}${r.source}`,de=fe.split(`
+`).length-1,We=m.byteLength(ce),ze=M+(r.isModule?0:z),Ge=Math.max(0,We-ze),Ve=r.isModule?m.byteLength(V):0,Ye=Math.max(0,Ve-z),Ke=Math.min(x,R+Math.max(Ge,Ye)),Qe=Math.min(Le,Math.max(u,r.isModule?m.byteLength(JSON.stringify(V)):0)),Xe=n===Number.POSITIVE_INFINITY?x:Math.min(Math.max(1,n-Date.now()),x);try{await N.run(!0,async()=>{let t;w.runTrusted(()=>{t=He.run({abortSignal:s,limits:{maxBridgeRequests:Math.min(Math.max(1,e.limits.maxJsBridgeRequests+(r.isModule?4:2)),x),maxConsoleOutputBytes:1,maxHostFunctionArgumentsBytes:u,maxHostFunctionOutputBytes:Qe,maxResultBytes:Math.min(e.limits.maxWorkerMessageBytes,x),maxSourceBytes:Ke,memoryLimitBytes:it,timeoutMs:Xe},moduleLoader:Je,source:ce,sourceType:r.isModule?"module":"function-body"})}),await t})}catch(t){let i=T(t),a=t instanceof Error&&t.stack!==void 0?Q(t.stack):void 0,p=G!==""&&a!==void 0&&(a.file===U||!r.isModule&&a.file==="run.js"&&a.line<=de);if(v!==void 0)f.exitCode=v;else if(L||t instanceof nt)L=!0,re();else if(H!==void 0||p)f.exitCode=1,j(`js-exec: bootstrap error: ${H??S(i)}
+`);else if(t instanceof Oe||t instanceof rt)f.exitCode=124,j(`js-exec: ${t instanceof Oe||o.aborted?`Execution timeout: exceeded ${e.limits.maxJsTimeoutMs}ms limit`:"Execution aborted"}
+`);else{f.exitCode=1;let b=st.isInstance(t)&&t.code==="RUN_ERROR",g=b?yt(t,r,de):D(i),A=b&&t instanceof Error&&t.stack?.includes("(<run-worker>)")===!0&&Q(t.stack)===void 0;j(b?A?`${g}
+`:g===i?`js-exec: ${D(i)}
+`:`${g}
+`:`js-exec: ${g}
+`)}}if(L&&re(),f.limitExceeded){f.exitCode=1;let t=O(`js-exec: total output size exceeded (>${_} bytes), increase executionLimits.maxOutputSize
+`,_),i=_-m.byteLength(t);f.stderr=O(f.stderr,i),i-=m.byteLength(f.stderr),f.stdout=O(f.stdout,i),f.stderr+=t}return{exitCode:f.exitCode,stderr:f.stderr,stdout:f.stdout}}async function Ne(r,e){if(N.getStore())return{exitCode:1,stderr:`js-exec: recursive invocation is not supported
+`,stdout:""};let s=new AbortController,n=e.limits.maxJsTimeoutMs===Number.POSITIVE_INFINITY?Number.POSITIVE_INFINITY:Date.now()+e.limits.maxJsTimeoutMs,o=pe(()=>s.abort(),e.limits.maxJsTimeoutMs),u=me(e.signal,s.signal);try{return await gt(async()=>await _t(r,e,u.signal,n,s.signal),u.signal)}catch(l){if(!(l instanceof q))throw l;let c=s.signal.aborted;return St(`js-exec: ${c?`Execution timeout: exceeded ${e.limits.maxJsTimeoutMs}ms limit`:"Execution aborted"}
+`,124,e.limits.maxOutputSize)}finally{u.cleanup(),he(o)}}var $e=`js-exec - Sandboxed JavaScript/TypeScript runtime with Node.js-compatible APIs
+
+Usage: js-exec [OPTIONS] [-c CODE | FILE] [ARGS...]
+
+Options:
+  -c CODE          Execute inline code
+  -m, --module     Enable ES module mode (import/export)
+  --strip-types    Accepted for compatibility; type stripping is automatic
+  --version, -V    Show version
+  --help           Show this help
+
+Examples:
+  js-exec -c "console.log(1 + 2)"
+  js-exec script.js
+  js-exec app.ts
+  echo 'console.log("hello")' | js-exec
+
+File Extension Auto-Detection:
+  .js              function-body mode
+  .mjs             ES module mode
+  .ts, .mts        ES module mode + TypeScript stripping
+
+Node.js Compatibility:
+  Code written for Node.js largely works here. Both require and import are
+  supported for the documented built-ins. Filesystem and command APIs retain
+  synchronous Node.js call semantics inside the sandbox.
+
+  Available modules:
+    fs, path, child_process, process, console,
+    os, url, assert, util, events, buffer, stream,
+    string_decoder, querystring
+
+Limits:
+  Memory: 64 MB per execution
+  Timeout: configurable via maxJsTimeoutMs
+  File reads: up to ~24 MB per file
+  File writes: up to ~6 MB cumulative per execution (reads unlimited)
+  Engine: run (QuickJS)
+`;function wt(r){let e={code:null,isModule:!1,scriptArgs:[],scriptFile:null,showVersion:!1};for(let s=0;s<r.length;s++){let n=r[s];if(n==="-m"||n==="--module"){e.isModule=!0;continue}if(n!=="--strip-types")return n==="-c"?s+1>=r.length?{exitCode:2,stderr:`js-exec: option requires an argument -- 'c'
+`,stdout:""}:(e.code=r[s+1],e.scriptArgs=r.slice(s+2),e):n==="--version"||n==="-V"?(e.showVersion=!0,e):n.startsWith("-")&&n!=="-"&&n!=="--"?{exitCode:2,stderr:`js-exec: unrecognized option '${n}'
+`,stdout:""}:n==="--"?(s+1<r.length&&(e.scriptFile=r[s+1],e.scriptArgs=r.slice(s+2)),e):n==="-"?(e.scriptArgs=r.slice(s+1),e):(e.scriptFile=n,e.scriptArgs=r.slice(s+1),e)}return e}var Wt={name:"js-exec",async execute(r,e){if(ye(r))return{exitCode:0,stderr:"",stdout:$e};let s=wt(r);if("exitCode"in s)return s;if(s.showVersion)return{exitCode:0,stderr:"",stdout:`QuickJS (run)
+`};let n,o;if(s.code!==null)n=s.code,o="-c";else if(s.scriptFile!==null){let l=e.fs.resolvePath(e.cwd,s.scriptFile);if(!await e.fs.exists(l))return{exitCode:2,stderr:`js-exec: can't open file '${s.scriptFile}': No such file or directory
+`,stdout:""};try{n=await e.fs.readFile(l),o=l}catch(c){return{exitCode:2,stderr:`js-exec: can't open file '${s.scriptFile}': ${S(c.message)}
+`,stdout:""}}}else if(Y(e.stdin).trim())n=Y(e.stdin),o="<stdin>";else return{exitCode:2,stderr:`js-exec: no input provided (use -c CODE or provide a script file)
+`,stdout:""};let u=s.isModule||o.endsWith(".mjs")||o.endsWith(".mts")||o.endsWith(".ts");return await Ne({bootstrapCode:e.jsBootstrapCode,isModule:u,scriptArgs:s.scriptArgs,scriptPath:o,source:n},e)}},zt={name:"node",async execute(){return{exitCode:1,stderr:`node: this sandbox uses js-exec instead of node
+
+${$e}`,stdout:""}}};export{Wt as jsExecCommand,zt as nodeStubCommand};