@ai-ecoverse/slicc-jsh 0.2.0 → 0.3.0

package/dist/node.mjs

@@ -1536,6 +1536,952 @@ ${e3}`;
   }
 });
 
+// src/runtime/exit.mjs
+var NodeExitError = class extends Error {
+  constructor(code) {
+    super(`Process exited with code ${code}`);
+    this.name = "NodeExitError";
+    this.code = code;
+  }
+};
+function numericExitCode(value) {
+  const n = Number(value);
+  return Number.isFinite(n) ? n & 255 : 0;
+}
+function describeReceived(value) {
+  if (typeof value === "string") return `type string ('${value}')`;
+  if (typeof value === "boolean") return `type boolean (${value})`;
+  if (typeof value === "bigint") return `type bigint (${value}n)`;
+  if (Array.isArray(value)) return "an instance of Array";
+  if (typeof value === "object" && value !== null) return "an instance of Object";
+  return `type ${typeof value}`;
+}
+function assignProcessExitCode(value) {
+  if (value === null || value === void 0) return void 0;
+  if (typeof value === "string") {
+    const n = Number(value);
+    if (value !== "" && Number.isInteger(n)) return n === 0 ? 0 : n;
+    const err2 = new TypeError(
+      `The "code" argument must be of type number. Received ${describeReceived(value)}`
+    );
+    err2.code = "ERR_INVALID_ARG_TYPE";
+    throw err2;
+  }
+  if (typeof value === "number") {
+    if (Number.isInteger(value)) return value === 0 ? 0 : value;
+    const err2 = new RangeError(
+      `The value of "code" is out of range. It must be an integer. Received ${String(value)}`
+    );
+    err2.code = "ERR_OUT_OF_RANGE";
+    throw err2;
+  }
+  const err = new TypeError(
+    `The "code" argument must be of type number. Received ${describeReceived(value)}`
+  );
+  err.code = "ERR_INVALID_ARG_TYPE";
+  throw err;
+}
+
+// package.json
+var package_default = {
+  name: "@ai-ecoverse/slicc-jsh",
+  version: "0.3.0",
+  description: "Node.js-compatible runtime for slicc-kernel: the node and jsh commands (abi: js)",
+  type: "module",
+  license: "Apache-2.0",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/ai-ecoverse/slicc-jsh.git"
+  },
+  homepage: "https://github.com/ai-ecoverse/slicc-jsh",
+  bugs: {
+    url: "https://github.com/ai-ecoverse/slicc-jsh/issues"
+  },
+  bin: {
+    jsh: "dist/host/jsh.mjs"
+  },
+  engines: {
+    node: ">=22",
+    "slicc-kernel": ">=1.53.2"
+  },
+  publishConfig: {
+    access: "public",
+    provenance: true
+  },
+  fledgling: {
+    provider: "github",
+    workflow: "release.yml",
+    repo: "ai-ecoverse/slicc-jsh",
+    publish: true
+  },
+  files: [
+    "LICENSE",
+    "NOTICE",
+    "README.md",
+    "dist"
+  ],
+  slicc: {
+    commands: {
+      node: {
+        abi: "js",
+        module: "dist/node.mjs",
+        argv0: "node"
+      },
+      jsh: {
+        abi: "js",
+        module: "dist/jsh.mjs",
+        argv0: "jsh"
+      }
+    },
+    binfmt: {
+      ".jsh": "jsh"
+    }
+  },
+  scripts: {
+    build: "node scripts/build.mjs && node scripts/build-host.mjs",
+    prepack: "npm run build",
+    prepare: "npm run build",
+    lint: "node scripts/lint.mjs",
+    test: "npm run test:golden && npm run test:jsh && npm run test:integration",
+    "test:golden": "node --max-old-space-size=512 scripts/golden.mjs check",
+    "test:integration": "node --max-old-space-size=512 --test --test-timeout=120000 test/integration/*.test.mjs",
+    "test:cert": "node --max-old-space-size=512 test/integration/cert/run.mjs",
+    "test:node-parallel": "node --max-old-space-size=512 test/node-parallel/run.mjs",
+    "golden:record": "node --max-old-space-size=512 scripts/golden.mjs record",
+    "test:jsh": "node --max-old-space-size=512 scripts/jsh-golden.mjs check",
+    "jsh:record": "node --max-old-space-size=512 scripts/jsh-golden.mjs record",
+    release: "semantic-release",
+    trust: "npx fledgling sync -y --skip-publish",
+    "trust:dry": "npx fledgling sync --dry-run -y --skip-publish"
+  },
+  devDependencies: {
+    "@ai-ecoverse/slicc-kernel": "1.59.0",
+    "@ai-ecoverse/wasi-pnpm": "12.9.1-8",
+    "abort-controller": "3.0.0",
+    acorn: "8.19.0",
+    esbuild: "0.28.2",
+    "node-inspect-extracted": "3.3.4",
+    process: "0.11.10",
+    "readable-stream": "4.8.0",
+    "semantic-release": "25.0.9",
+    string_decoder: "1.3.0",
+    ws: "8.22.0"
+  }
+};
+
+// src/jsh/parse-flags.mjs
+function parseFlags(argv) {
+  const positional = [];
+  const flags = {};
+  const passthrough = [];
+  const set = (key, value) => {
+    if (key in flags) {
+      const prev = flags[key];
+      if (Array.isArray(prev)) prev.push(String(value));
+      else flags[key] = [String(prev), String(value)];
+    } else {
+      flags[key] = value;
+    }
+  };
+  let i2 = 2;
+  while (i2 < argv.length) {
+    const arg = argv[i2];
+    if (arg === "--") {
+      passthrough.push(...argv.slice(i2 + 1));
+      break;
+    }
+    if (arg.startsWith("--")) {
+      const body = arg.slice(2);
+      const eq = body.indexOf("=");
+      if (eq !== -1) {
+        set(body.slice(0, eq), body.slice(eq + 1));
+        i2++;
+        continue;
+      }
+      const next = argv[i2 + 1];
+      if (next !== void 0 && !next.startsWith("-")) {
+        set(body, next);
+        i2 += 2;
+        continue;
+      }
+      set(body, true);
+      i2++;
+      continue;
+    }
+    if (arg.startsWith("-") && arg.length > 1) {
+      for (const ch of arg.slice(1)) set(ch, true);
+      i2++;
+      continue;
+    }
+    positional.push(arg);
+    i2++;
+  }
+  const subcommand = positional.length > 0 && /^[a-z][\w-]*$/i.test(positional[0]) ? positional[0] : null;
+  return { positional, flags, subcommand, passthrough };
+}
+function attachParseFlags(argv) {
+  if (Object.prototype.hasOwnProperty.call(argv, "parseFlags")) return argv;
+  Object.defineProperty(argv, "parseFlags", {
+    value: () => parseFlags(argv),
+    enumerable: false,
+    writable: false,
+    configurable: true
+  });
+  return argv;
+}
+
+// src/jsh/sliccy/exec.mjs
+var SIGNALS = { SIGHUP: 1, SIGINT: 2, SIGQUIT: 3, SIGKILL: 9, SIGTERM: 15 };
+function killExitCode(sig = "SIGTERM") {
+  const n = typeof sig === "number" ? sig : SIGNALS[sig] ?? 15;
+  return 128 + n;
+}
+function createExec(engine) {
+  const shellArgv = (command, args = []) => [...engine.shell, command, "jsh", ...args];
+  const run = (argv, stdin) => engine.spawn(argv, { stdin }).done;
+  const exec = (command) => {
+    if (typeof command !== "string") throw new TypeError("exec(command): command must be a string");
+    return run(shellArgv(command));
+  };
+  exec.spawn = (argv) => {
+    if (!Array.isArray(argv) || argv.length === 0) {
+      throw new TypeError("exec.spawn(argv): argv must be a non-empty array");
+    }
+    return run(argv.map(String));
+  };
+  exec.start = (commandOrArgv, opts = {}) => {
+    const argv = Array.isArray(commandOrArgv) ? [...commandOrArgv.map(String), ...(opts.args ?? []).map(String)] : shellArgv(String(commandOrArgv), (opts.args ?? []).map(String));
+    const chunks = [];
+    let child = null;
+    let killed = false;
+    let resolveDone;
+    let rejectDone;
+    const done = new Promise((resolve2, reject) => {
+      resolveDone = resolve2;
+      rejectDone = reject;
+    });
+    const fire = () => {
+      if (child || killed) return;
+      const stdin = chunks.length > 0 ? chunks.join("") : opts.stdin;
+      child = engine.spawn(argv, { stdin });
+      child.done.then(resolveDone, rejectDone);
+    };
+    return {
+      kill(sig) {
+        if (child) return Promise.resolve(child.kill(sig ?? "SIGTERM")).then(() => true);
+        killed = true;
+        resolveDone({ stdout: "", stderr: "", exitCode: killExitCode(sig) });
+        return Promise.resolve(true);
+      },
+      stdin: {
+        write(chunk) {
+          if (!child && !killed) chunks.push(String(chunk));
+        },
+        end: () => fire()
+      },
+      done
+    };
+  };
+  exec.exec = exec;
+  return exec;
+}
+function dirnameOf(path) {
+  if (!path) return "";
+  const idx = path.lastIndexOf("/");
+  if (idx < 0) return "";
+  if (idx === 0) return "/";
+  return path.slice(0, idx);
+}
+function joinChild(dir, name) {
+  if (dir === "") return name;
+  if (dir === "/") return `/${name}`;
+  return `${dir}/${name}`;
+}
+function createSkill({ argv, fs, exec }) {
+  const dir = dirnameOf(argv[1] ?? "");
+  const refs = joinChild(dir, "references");
+  const assets = joinChild(dir, "assets");
+  const configPath = joinChild(dir, ".config");
+  async function readConfig() {
+    let text;
+    try {
+      if (!fs.existsSync(configPath)) return null;
+      text = await fs.promises.readFile(configPath, "utf8");
+    } catch {
+      return null;
+    }
+    if (!String(text).trim()) return null;
+    let parsed;
+    try {
+      parsed = JSON.parse(text);
+    } catch (err) {
+      throw new Error(`skill.config(): failed to parse ${configPath}: ${err?.message ?? err}`);
+    }
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+    throw new Error(`skill.config(): ${configPath} must contain a JSON object`);
+  }
+  async function config(updates) {
+    const existing = await readConfig();
+    if (updates === void 0) return existing;
+    if (updates === null || typeof updates !== "object" || Array.isArray(updates)) {
+      throw new TypeError("skill.config(updates): updates must be a plain object");
+    }
+    const merged = { ...existing ?? {}, ...updates };
+    await fs.promises.writeFile(configPath, `${JSON.stringify(merged, null, 2)}
+`);
+    return merged;
+  }
+  async function token(providerId) {
+    if (typeof providerId !== "string" || !providerId.trim()) {
+      throw new TypeError("skill.token(providerId): providerId must be a non-empty string");
+    }
+    const { stdout, stderr, exitCode } = await exec.spawn(["oauth-token", providerId]);
+    if (exitCode !== 0) {
+      const msg = stderr.trim() || `oauth-token exited with code ${exitCode}`;
+      throw new Error(`skill.token('${providerId}'): ${msg}`);
+    }
+    return stdout.replace(/\r?\n+$/, "");
+  }
+  return Object.freeze({ dir, refs, assets, config, token });
+}
+
+// src/jsh/sliccy/http.mjs
+var HttpError = class extends Error {
+  constructor(status, statusText, url, body) {
+    const detail = typeof body === "string" && body ? `: ${body.slice(0, 200)}` : body && typeof body === "object" ? `: ${safeJson(body).slice(0, 200)}` : "";
+    super(`HTTP ${status} ${statusText} ${url}${detail}`);
+    this.name = "HttpError";
+    this.status = status;
+    this.statusText = statusText;
+    this.url = url;
+    this.body = body;
+  }
+};
+function safeJson(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+var DEFAULT_BACKOFF_BASE_MS = 500;
+function buildUrl(baseUrl, path, params) {
+  let url;
+  if (/^[a-z][a-z0-9+.-]*:\/\//i.test(path)) url = path;
+  else if (baseUrl) {
+    const base = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+    url = `${base}${path.startsWith("/") ? path : `/${path}`}`;
+  } else url = path;
+  if (!params) return url;
+  const qs = [];
+  const push = (k, v) => qs.push(`${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`);
+  for (const [k, v] of Object.entries(params)) {
+    if (v === void 0 || v === null) continue;
+    if (Array.isArray(v)) {
+      for (const item of v) if (item !== void 0 && item !== null) push(k, item);
+    } else push(k, v);
+  }
+  if (qs.length === 0) return url;
+  return url + (url.includes("?") ? "&" : "?") + qs.join("&");
+}
+function isJsonContentType(ct) {
+  if (!ct) return false;
+  const lower = ct.toLowerCase();
+  return lower.startsWith("application/json") || /[+/]json(;|$|\s)/.test(lower);
+}
+function parseRetryAfter(value) {
+  const trimmed = value?.trim();
+  if (!trimmed) return null;
+  if (/^\d+(\.\d+)?$/.test(trimmed)) {
+    const seconds = Number(trimmed);
+    if (Number.isFinite(seconds) && seconds >= 0) return Math.round(seconds * 1e3);
+  }
+  const date = Date.parse(trimmed);
+  if (Number.isFinite(date)) return Math.max(0, date - Date.now());
+  return null;
+}
+async function readBody(resp) {
+  if (isJsonContentType(resp.headers.get("content-type"))) {
+    const text = await resp.text();
+    if (!text) return null;
+    try {
+      return JSON.parse(text);
+    } catch {
+      return text;
+    }
+  }
+  return resp.text();
+}
+function serializeBody(body, headers) {
+  if (body === void 0 || body === null) return void 0;
+  if (typeof body === "string") return body;
+  if (body instanceof ArrayBuffer || ArrayBuffer.isView(body) || typeof Blob !== "undefined" && body instanceof Blob || typeof FormData !== "undefined" && body instanceof FormData || typeof URLSearchParams !== "undefined" && body instanceof URLSearchParams || typeof ReadableStream !== "undefined" && body instanceof ReadableStream) {
+    return body;
+  }
+  if (typeof body === "object") {
+    if (!Object.keys(headers).some((k) => k.toLowerCase() === "content-type")) {
+      headers["Content-Type"] = "application/json";
+    }
+    return JSON.stringify(body);
+  }
+  return String(body);
+}
+function createHttp({ fetch, sleep = (ms) => new Promise((r) => setTimeout(r, ms)) }) {
+  function makeClient(config = {}) {
+    const retryOn = new Set(config.retry?.on ?? []);
+    const maxAttempts = Math.max(1, Math.trunc(config.retry?.maxAttempts ?? 1));
+    async function request(method, path, opts = {}) {
+      if (typeof fetch !== "function") throw new Error("sliccy:http: fetch is not available");
+      const url = buildUrl(config.baseUrl, path, opts.params);
+      const headers = { ...config.headers ?? {}, ...opts.headers ?? {} };
+      if (config.token) {
+        const tok = await config.token({ method, path, url });
+        if (tok && !Object.keys(headers).some((k) => k.toLowerCase() === "authorization")) {
+          headers.Authorization = `Bearer ${tok}`;
+        }
+      }
+      const body = serializeBody(opts.body, headers);
+      const init = { method, headers };
+      if (body !== void 0) init.body = body;
+      for (let attempt = 0; ; attempt++) {
+        const timeoutCtl = config.timeoutMs ? new AbortController() : null;
+        const timeoutId = timeoutCtl ? setTimeout(() => timeoutCtl.abort(new Error("timeout")), config.timeoutMs) : null;
+        const signal = opts.signal && timeoutCtl ? AbortSignal.any([opts.signal, timeoutCtl.signal]) : opts.signal ?? timeoutCtl?.signal;
+        let resp;
+        try {
+          resp = await fetch(url, signal ? { ...init, signal } : init);
+        } finally {
+          if (timeoutId !== null) clearTimeout(timeoutId);
+        }
+        if (resp.ok) {
+          const respBody = await readBody(resp);
+          if (opts.raw) {
+            return {
+              body: respBody,
+              headers: Object.fromEntries(resp.headers.entries()),
+              status: resp.status
+            };
+          }
+          return respBody;
+        }
+        if (attempt + 1 >= maxAttempts || !retryOn.has(resp.status)) {
+          const errBody = await readBody(resp).catch(() => null);
+          throw new HttpError(resp.status, resp.statusText, url, errBody);
+        }
+        const retryAfter = parseRetryAfter(resp.headers.get("retry-after"));
+        await sleep(retryAfter ?? DEFAULT_BACKOFF_BASE_MS * 2 ** attempt);
+      }
+    }
+    return Object.freeze({
+      get: (path, opts) => request("GET", path, opts),
+      post: (path, opts) => request("POST", path, opts),
+      put: (path, opts) => request("PUT", path, opts),
+      patch: (path, opts) => request("PATCH", path, opts),
+      delete: (path, opts) => request("DELETE", path, opts)
+    });
+  }
+  return Object.freeze({ client: makeClient, HttpError });
+}
+
+// src/jsh/sliccy/pure.mjs
+var ANSI = {
+  reset: "\x1B[0m",
+  green: "\x1B[32m",
+  red: "\x1B[31m",
+  yellow: "\x1B[33m",
+  gray: "\x1B[90m",
+  bold: "\x1B[1m",
+  cyan: "\x1B[36m",
+  dim: "\x1B[2m"
+};
+function colorEnabled(env, stdoutIsTTY) {
+  const force = env?.FORCE_COLOR;
+  if (force !== void 0) return force !== "" && force !== "0" && force !== "false";
+  if (env?.NO_COLOR) return false;
+  return !!stdoutIsTTY;
+}
+function createColor(enabled) {
+  const wrap = (code) => (s) => enabled ? `${code}${s}${ANSI.reset}` : String(s);
+  return Object.freeze({
+    enabled,
+    green: wrap(ANSI.green),
+    red: wrap(ANSI.red),
+    yellow: wrap(ANSI.yellow),
+    gray: wrap(ANSI.gray),
+    bold: wrap(ANSI.bold),
+    cyan: wrap(ANSI.cyan),
+    dim: wrap(ANSI.dim)
+  });
+}
+function createCli({ writeStdout, writeStderr, exit, color }) {
+  const toLine = (v) => {
+    if (typeof v === "string") return v;
+    if (v instanceof Error) return v.message;
+    if (v === null || v === void 0) return String(v);
+    try {
+      return JSON.stringify(v);
+    } catch {
+      return String(v);
+    }
+  };
+  const prefixed = (paint, prefix, text, fallback) => {
+    if (prefix === void 0) return `${paint(`${fallback}:`)} ${text}
+`;
+    if (prefix === "") return `${paint(text)}
+`;
+    return `${paint(`${prefix}:`)} ${text}
+`;
+  };
+  const prefixOf = (opts) => typeof opts === "object" && opts !== null && "prefix" in opts ? opts.prefix : void 0;
+  return Object.freeze({
+    die(msg, opts) {
+      const code = typeof opts === "number" ? opts : opts?.exitCode ?? 1;
+      writeStderr(prefixed(color.red, prefixOf(opts), toLine(msg), "Error"));
+      exit(code);
+      throw new Error("unreachable");
+    },
+    out(value) {
+      if (typeof value === "string") {
+        writeStdout(value.endsWith("\n") ? value : `${value}
+`);
+        return;
+      }
+      try {
+        writeStdout(`${JSON.stringify(value, null, 2)}
+`);
+      } catch {
+        writeStdout(`${String(value)}
+`);
+      }
+    },
+    warn(msg, opts) {
+      writeStderr(prefixed(color.yellow, prefixOf(opts), toLine(msg), "Warning"));
+    },
+    help(text) {
+      writeStdout(text.endsWith("\n") ? text : `${text}
+`);
+      exit(0);
+      throw new Error("unreachable");
+    }
+  });
+}
+var ANSI_RE = /\u001b\[[0-9;]*m/g;
+var stripAnsi = (s) => s.replace(ANSI_RE, "");
+var visibleLength = (s) => stripAnsi(s).length;
+var pad2 = (n) => n < 10 ? `0${n}` : String(n);
+function trunc(s, n) {
+  const text = String(s ?? "");
+  if (n <= 0) return "";
+  if (visibleLength(text) <= n) return text;
+  if (n <= 1) return text.slice(0, n);
+  return `${stripAnsi(text).slice(0, n - 1)}\u2026`;
+}
+function col(s, width) {
+  const text = String(s ?? "");
+  const vis = visibleLength(text);
+  if (vis === width) return text;
+  if (vis > width) return trunc(text, width);
+  return text + " ".repeat(width - vis);
+}
+function table(rows, widths) {
+  if (!rows.length) return "";
+  const colCount = Math.max(...rows.map((r) => r.length));
+  const computed = [];
+  for (let i2 = 0; i2 < colCount; i2++) {
+    if (widths && widths[i2] !== void 0) {
+      computed[i2] = widths[i2];
+    } else {
+      let max = 0;
+      for (const r of rows) max = Math.max(max, visibleLength(i2 < r.length ? String(r[i2] ?? "") : ""));
+      computed[i2] = max;
+    }
+  }
+  return rows.map(
+    (r) => computed.map((w, i2) => col(i2 < r.length ? String(r[i2] ?? "") : "", w)).join("  ").replace(/\s+$/, "")
+  ).join("\n");
+}
+function fmtDate(value, style = "short") {
+  const d = value instanceof Date ? value : new Date(value);
+  if (Number.isNaN(d.getTime())) return String(value);
+  if (style === "iso") return d.toISOString();
+  if (style === "locale") return new Intl.DateTimeFormat(void 0, { dateStyle: "medium" }).format(d);
+  if (style === "human") {
+    const diff = Date.now() - d.getTime();
+    const abs = Math.abs(diff);
+    if (abs < 6e4) return diff >= 0 ? "just now" : "in a moment";
+    const tense = (n, u) => diff >= 0 ? `${n} ${u}${n === 1 ? "" : "s"} ago` : `in ${n} ${u}${n === 1 ? "" : "s"}`;
+    if (abs < 36e5) return tense(Math.round(abs / 6e4), "minute");
+    if (abs < 864e5) return tense(Math.round(abs / 36e5), "hour");
+    if (abs < 26298e5) return tense(Math.round(abs / 864e5), "day");
+    if (abs < 315576e5) return tense(Math.round(abs / 26298e5), "month");
+    return tense(Math.round(abs / 315576e5), "year");
+  }
+  return `${d.getFullYear()}-${pad2(d.getMonth() + 1)}-${pad2(d.getDate())}`;
+}
+var fmt = Object.freeze({ trunc, col, table, date: fmtDate });
+var DURATION_UNITS_MS = {
+  ms: 1,
+  s: 1e3,
+  m: 6e4,
+  h: 36e5,
+  d: 864e5,
+  w: 6048e5,
+  M: 26298e5,
+  y: 315576e5
+};
+function parseDuration(spec) {
+  if (typeof spec === "number" && Number.isFinite(spec)) return Math.trunc(spec);
+  if (typeof spec !== "string") throw new TypeError("time.parseDuration: spec must be string or number");
+  const m = /^([0-9]+(?:\.[0-9]+)?)\s*(ms|s|m|h|d|w|M|y)?$/.exec(spec.trim());
+  if (!m) throw new RangeError(`time.parseDuration: unrecognized spec "${spec}"`);
+  return Math.trunc(Number(m[1]) * DURATION_UNITS_MS[m[2] ?? "ms"]);
+}
+var time = Object.freeze({
+  parseDuration,
+  ago(spec, from = /* @__PURE__ */ new Date()) {
+    return new Date(from.getTime() - parseDuration(spec));
+  },
+  range(spec, from = /* @__PURE__ */ new Date()) {
+    const end = new Date(from.getTime());
+    return { start: new Date(end.getTime() - parseDuration(spec)), end };
+  },
+  future(spec, from = /* @__PURE__ */ new Date()) {
+    const start = new Date(from.getTime());
+    return { start, end: new Date(start.getTime() + parseDuration(spec)) };
+  },
+  gmailDate(spec, from = /* @__PURE__ */ new Date()) {
+    const d = new Date(from.getTime() - parseDuration(spec));
+    return `${d.getFullYear()}/${pad2(d.getMonth() + 1)}/${pad2(d.getDate())}`;
+  }
+});
+async function pool(concurrency, items, fn) {
+  const n = Math.max(1, Math.trunc(concurrency) || 1);
+  const results = new Array(items.length);
+  let next = 0;
+  const worker = async () => {
+    for (; ; ) {
+      const i2 = next++;
+      if (i2 >= items.length) return;
+      results[i2] = await fn(items[i2], i2);
+    }
+  };
+  const workers = [];
+  for (let w = 0; w < Math.min(n, items.length); w++) workers.push(worker());
+  await Promise.all(workers);
+  return results;
+}
+
+// src/jsh/sliccy/index.mjs
+var SLICC_ONLY = /* @__PURE__ */ new Set(["agent", "usb", "serial", "hid", "computer"]);
+function isNotFound(err, request) {
+  return err?.code === "MODULE_NOT_FOUND" && String(err.message).includes(`'${request}'`);
+}
+function createSliccyResolver({ engine, process: process2, require: require2 }) {
+  let color;
+  let exec;
+  const getColor = () => {
+    color ??= createColor(colorEnabled(process2.env, engine.stdoutIsTTY));
+    return color;
+  };
+  const getExec = () => {
+    exec ??= createExec(engine);
+    return exec;
+  };
+  const factories = {
+    cli: () => createCli({
+      writeStdout: engine.writeStdout,
+      writeStderr: engine.writeStderr,
+      exit: (code) => process2.exit(code),
+      color: getColor()
+    }),
+    color: getColor,
+    exec: getExec,
+    fmt: () => fmt,
+    http: () => createHttp({ fetch: engine.fetch }),
+    pool: () => pool,
+    skill: () => createSkill({ argv: process2.argv, fs: require2("fs"), exec: getExec() }),
+    time: () => time
+  };
+  const cache2 = /* @__PURE__ */ new Map();
+  const lookups = [require2, engine.selfRequire].filter(Boolean);
+  return function requireSliccy(id) {
+    const name = id.slice("sliccy:".length);
+    if (name === "") throw new Error("require('sliccy:'): empty sliccy: module name");
+    if (cache2.has(name)) return cache2.get(name);
+    let value;
+    if (Object.prototype.hasOwnProperty.call(factories, name)) {
+      value = factories[name]();
+    } else {
+      value = findPackage(name, lookups);
+    }
+    if (value === void 0) {
+      if (SLICC_ONLY.has(name)) {
+        throw new Error(`require('${id}'): sliccy:${name} is only available inside SLICC`);
+      }
+      const known = Object.keys(factories).sort().join(", ");
+      throw new Error(
+        `require('${id}'): unknown sliccy: module '${name}'. Known names: ${known}. Install @ai-ecoverse/sliccy-${name} to provide it.`
+      );
+    }
+    cache2.set(name, value);
+    return value;
+  };
+}
+function findPackage(name, lookups) {
+  for (const pkg of [`@ai-ecoverse/sliccy-${name}`, `sliccy-${name}`]) {
+    for (const req of lookups) {
+      try {
+        return req(pkg);
+      } catch (err) {
+        if (!isNotFound(err, pkg)) throw err;
+      }
+    }
+  }
+  return void 0;
+}
+
+// src/jsh/run.mjs
+var JSH_VERSION = package_default.version;
+var JSH_PARAMS = Object.freeze([
+  "process",
+  "console",
+  "require",
+  "module",
+  "exports",
+  "fetch",
+  "__dirname",
+  "__filename"
+]);
+var JSH_USAGE = `Usage: jsh [--version | --help] <script.jsh> [args...]
+
+Runs a .jsh script: the body of an async function with process, console,
+require, module, exports, fetch, __dirname and __filename in scope.
+`;
+function parseJshArgv(args) {
+  let i2 = 0;
+  const first = args[0];
+  if (first === "--version" || first === "-v") return { action: "version" };
+  if (first === "--help" || first === "-h") return { action: "help" };
+  if (first === "--") i2 = 1;
+  else if (first?.startsWith("-") && first !== "-") {
+    return { action: "error", message: `jsh: bad option: ${first}`, status: 9 };
+  }
+  if (i2 >= args.length) return { action: "usage" };
+  return { action: "run", script: args[i2], args: args.slice(i2 + 1) };
+}
+function prepareSource(source) {
+  let text = source.charCodeAt(0) === 65279 ? source.slice(1) : source;
+  if (text.startsWith("#!")) {
+    const nl = text.indexOf("\n");
+    text = nl === -1 ? "" : text.slice(nl);
+  }
+  return text;
+}
+function dirnameOf2(path) {
+  const idx = path.lastIndexOf("/");
+  if (idx <= 0) return "/";
+  return path.slice(0, idx);
+}
+function wrapRequire(baseRequire, requireSliccy, module) {
+  const require2 = (id) => typeof id === "string" && id.startsWith("sliccy:") ? requireSliccy(id) : baseRequire(id);
+  const resolve2 = (id, options) => typeof id === "string" && id.startsWith("sliccy:") ? id : baseRequire.resolve(id, options);
+  resolve2.paths = (id) => baseRequire.resolve.paths?.(id) ?? null;
+  require2.resolve = resolve2;
+  require2.cache = baseRequire.cache;
+  require2.main = module;
+  return require2;
+}
+async function runJsh({ filename, engine, process: process2, console: console2 }) {
+  let source;
+  try {
+    source = engine.readSource(filename);
+  } catch (err) {
+    engine.writeStderr(`jsh: cannot open ${filename}: ${err?.code ?? err?.message ?? err}
+`);
+    return engine.exit(1);
+  }
+  attachParseFlags(process2.argv);
+  try {
+    process2.versions.jsh = JSH_VERSION;
+  } catch {
+  }
+  const dirname2 = dirnameOf2(filename);
+  const module = {
+    id: ".",
+    filename,
+    path: dirname2,
+    exports: {},
+    loaded: false,
+    children: [],
+    paths: []
+  };
+  const baseRequire = engine.createRequire(filename);
+  const requireSliccy = createSliccyResolver({ engine, process: process2, require: baseRequire });
+  const require2 = wrapRequire(baseRequire, requireSliccy, module);
+  try {
+    const fn = engine.compile(prepareSource(source), filename);
+    await fn(process2, console2, require2, module, module.exports, engine.fetch, dirname2, filename);
+    module.loaded = true;
+  } catch (err) {
+    if (engine.isExit(err)) return engine.exit(err.code);
+    engine.writeStderr(`${err?.stack ?? err}
+`);
+    return engine.exit(1);
+  }
+  return void 0;
+}
+
+// src/jsh/kernel.mjs
+var JSH_HANDOFF = /* @__PURE__ */ Symbol.for("slicc-jsh.kernel");
+var decoder = new TextDecoder();
+var encoder = new TextEncoder();
+var AsyncFunction = Object.getPrototypeOf(async () => {
+}).constructor;
+async function readAll(stream) {
+  if (!stream) return new Uint8Array(0);
+  const chunks = [];
+  let size = 0;
+  const reader = stream.getReader();
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    const bytes = typeof value === "string" ? encoder.encode(value) : value;
+    chunks.push(bytes);
+    size += bytes.length;
+  }
+  const out = new Uint8Array(size);
+  let off = 0;
+  for (const c of chunks) {
+    out.set(c, off);
+    off += c.length;
+  }
+  return out;
+}
+async function writeAll(stream, data2) {
+  const writer = stream.getWriter();
+  try {
+    await writer.write(typeof data2 === "string" ? encoder.encode(data2) : data2);
+    await writer.close();
+  } catch {
+  }
+}
+function kernelSpawn(ctx, process2) {
+  return (argv, { stdin } = {}) => {
+    let child = null;
+    const done = (async () => {
+      try {
+        child = await ctx.spawn({
+          argv,
+          cwd: process2.cwd(),
+          env: { ...process2.env },
+          stdin: stdin === void 0 ? "null" : "pipe",
+          stdout: "pipe",
+          stderr: "pipe"
+        });
+      } catch (err2) {
+        if (err2?.code === "ENOENT") {
+          return { stdout: "", stderr: `${argv[0]}: command not found
+`, exitCode: 127 };
+        }
+        return { stdout: "", stderr: `${argv[0]}: ${err2?.message ?? err2}
+`, exitCode: 126 };
+      }
+      const [out, err, status] = await Promise.all([
+        readAll(child.stdout),
+        readAll(child.stderr),
+        child.wait(),
+        stdin === void 0 ? void 0 : writeAll(child.stdin, stdin)
+      ]);
+      return { stdout: decoder.decode(out), stderr: decoder.decode(err), exitCode: status.status };
+    })();
+    return {
+      kill: async (sig = "SIGTERM") => child ? child.kill(sig) : false,
+      done
+    };
+  };
+}
+function compiler(rt) {
+  return (body, filename) => {
+    const head = "(async function () {";
+    const { code, changed, binding = "__import" } = rt.rewriteDynamicImports(
+      `${head}${body}
+})`
+    );
+    const text = changed ? code.slice(head.length, -3) : body;
+    const params = changed ? [...JSH_PARAMS, binding] : [...JSH_PARAMS];
+    const fn = new AsyncFunction(...params, `${text}
+//# sourceURL=${filename}`);
+    if (!changed) return fn;
+    const importFrom = (specifier) => rt.importModule(specifier, filename);
+    return (...args) => fn(...args.slice(0, JSH_PARAMS.length), importFrom);
+  };
+}
+async function runKernelJsh(ctx, rt, filename) {
+  const { process: process2, console: console2 } = rt;
+  let stdoutIsTTY = false;
+  try {
+    stdoutIsTTY = !!await ctx.isatty?.(1);
+  } catch {
+    stdoutIsTTY = false;
+  }
+  const engine = {
+    readSource: (path) => decoder.decode(ctx.sync.fs.readFile(path)),
+    compile: compiler(rt),
+    createRequire: (path) => rt.createRequire(path),
+    selfRequire: rt.createRequire("/node_modules/@ai-ecoverse/slicc-jsh/package.json"),
+    writeStdout: (s) => process2.stdout.write(String(s)),
+    writeStderr: (s) => process2.stderr.write(String(s)),
+    stdoutIsTTY,
+    spawn: kernelSpawn(ctx, process2),
+    shell: ["sh", "-c"],
+    fetch: rt.fetch,
+    isExit: (err) => err instanceof NodeExitError,
+    exit: (code) => process2.exit(code)
+  };
+  await runJsh({ filename, engine, process: process2, console: console2 });
+}
+function installJshHandoff(ctx, rt) {
+  const handoff = Object.freeze({
+    version: JSH_VERSION,
+    async runJsh(args) {
+      const { process: process2 } = rt;
+      const parsed = parseJshArgv([...args]);
+      if (parsed.action === "version") return void process2.stdout.write(`${JSH_VERSION}
+`);
+      if (parsed.action === "help") return void process2.stdout.write(JSH_USAGE);
+      if (parsed.action === "usage") {
+        process2.stderr.write(JSH_USAGE);
+        return process2.exit(2);
+      }
+      if (parsed.action === "error") {
+        process2.stderr.write(`${parsed.message}
+${JSH_USAGE}`);
+        return process2.exit(parsed.status);
+      }
+      const filename = ctx.resolve(parsed.script);
+      process2.argv = ["jsh", filename, ...parsed.args];
+      return runKernelJsh(ctx, rt, filename);
+    }
+  });
+  try {
+    Object.defineProperty(globalThis, JSH_HANDOFF, {
+      value: handoff,
+      enumerable: false,
+      configurable: true,
+      writable: false
+    });
+  } catch {
+    return () => {
+    };
+  }
+  return () => {
+    try {
+      delete globalThis[JSH_HANDOFF];
+    } catch {
+    }
+  };
+}
+
 // src/runtime/async-handles.mjs
 function trackPromise(handles, promise) {
   const handle = { kind: "promise" };
@@ -1592,8 +2538,8 @@ async function drainLoop(handles, nextTick, { onBeforeExit, shouldStop } = {}) {
 }
 
 // src/runtime/buffer.mjs
-var encoder = new TextEncoder();
-var decoder = new TextDecoder();
+var encoder2 = new TextEncoder();
+var decoder2 = new TextDecoder();
 var INSPECT_CUSTOM = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
 function normalizeEncoding(enc) {
   if (!enc) return "utf8";
@@ -1665,7 +2611,7 @@ function asUint8(value, encoding = "utf8") {
       for (let i2 = 0; i2 < value.length; i2++) out[i2] = value.charCodeAt(i2) & 255;
       return out;
     }
-    return encoder.encode(value);
+    return encoder2.encode(value);
   }
   if (typeof value === "number") return new Uint8Array([value & 255]);
   if (ArrayBuffer.isView(value)) {
@@ -1673,7 +2619,7 @@ function asUint8(value, encoding = "utf8") {
   }
   if (value instanceof ArrayBuffer) return new Uint8Array(value);
   if (Array.isArray(value)) return Uint8Array.from(value);
-  return encoder.encode(String(value));
+  return encoder2.encode(String(value));
 }
 function toStringOf(bytes, encoding = "utf8", start = 0, end = bytes.length) {
   const slice = bytes.subarray(start, end);
@@ -1697,7 +2643,7 @@ function toStringOf(bytes, encoding = "utf8", start = 0, end = bytes.length) {
     for (const b of slice) out += String.fromCharCode(b);
     return out;
   }
-  return decoder.decode(slice);
+  return decoder2.decode(slice);
 }
 var float32Array = new Float32Array(1);
 var uInt8Float32Array = new Uint8Array(float32Array.buffer);
@@ -2973,9 +3919,9 @@ function codePointToString(code) {
   return String.fromCharCode((code >> 10) + 55296, (code & 1023) + 56320);
 }
 var loneSurrogate = /(?:[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])/;
-var Position = function Position2(line, col) {
+var Position = function Position2(line, col2) {
   this.line = line;
-  this.column = col;
+  this.column = col2;
 };
 Position.prototype.offset = function offset(n) {
   return new Position(this.line, this.column + n);
@@ -9847,9 +10793,418 @@ function createEvents() {
   });
 }
 
+// src/runtime/builtins/child-process.mjs
+var SIGNAL_NAMES = {
+  1: "SIGHUP",
+  2: "SIGINT",
+  3: "SIGQUIT",
+  6: "SIGABRT",
+  9: "SIGKILL",
+  10: "SIGUSR1",
+  12: "SIGUSR2",
+  13: "SIGPIPE",
+  14: "SIGALRM",
+  15: "SIGTERM",
+  17: "SIGCHLD",
+  18: "SIGCONT",
+  19: "SIGSTOP",
+  20: "SIGTSTP"
+};
+var SIGNAL_NUMBERS = Object.fromEntries(
+  Object.entries(SIGNAL_NAMES).map(([n, name]) => [name, Number(n)])
+);
+function notSupported(name) {
+  const err = new Error(`slicc-jsh: child_process.${name} is not supported yet`);
+  err.code = "ERR_NOT_SUPPORTED";
+  throw err;
+}
+function normalizeArgs(file, args, options, callback) {
+  if (typeof args === "function") {
+    return { args: [], options: {}, callback: args };
+  }
+  if (typeof options === "function") {
+    return { args: Array.isArray(args) ? args : [], options: {}, callback: options };
+  }
+  if (args != null && !Array.isArray(args) && typeof args === "object") {
+    return { args: [], options: args, callback: typeof options === "function" ? options : callback };
+  }
+  return {
+    args: Array.isArray(args) ? args.map(String) : [],
+    options: options && typeof options === "object" ? options : {},
+    callback: typeof callback === "function" ? callback : void 0
+  };
+}
+function normalizeStdio(stdio) {
+  if (stdio === void 0) return ["pipe", "pipe", "pipe"];
+  if (typeof stdio === "string") return [stdio, stdio, stdio];
+  if (Array.isArray(stdio)) {
+    return [stdio[0] ?? "pipe", stdio[1] ?? "pipe", stdio[2] ?? "pipe"];
+  }
+  return ["pipe", "pipe", "pipe"];
+}
+function toKernelStdio(mode) {
+  if (mode === "pipe" || mode === "overlapped") return "pipe";
+  if (mode === "ignore" || mode === null || mode === void 0 || mode === "null") return "null";
+  if (mode === "inherit") return "inherit";
+  if (typeof mode === "number") return mode;
+  const err = new Error(`The argument 'stdio' is invalid. Received ${String(mode)}`);
+  err.code = "ERR_INVALID_ARG_VALUE";
+  throw err;
+}
+function signalName(sig) {
+  if (sig == null) return null;
+  if (typeof sig === "string") return sig.startsWith("SIG") ? sig : `SIG${sig}`;
+  if (typeof sig === "number") return SIGNAL_NAMES[sig] ?? String(sig);
+  return null;
+}
+function spawnError(command, args, code, message) {
+  const err = new Error(message ?? `spawn ${command} ${code}`);
+  err.code = code;
+  err.errno = code === "ENOENT" ? -2 : void 0;
+  err.syscall = "spawn";
+  err.path = command;
+  err.spawnargs = args;
+  return err;
+}
+function createChildProcess({ ctx, process: process2, Buffer: Buffer2, handles, getStream }) {
+  class ChildProcess extends EventEmitter {
+    constructor() {
+      super();
+      this.stdin = null;
+      this.stdout = null;
+      this.stderr = null;
+      this.pid = void 0;
+      this.exitCode = null;
+      this.signalCode = null;
+      this.killed = false;
+      this.connected = false;
+      this.spawnfile = "";
+      this.spawnargs = [];
+      this.#kernel = null;
+      this.#handle = null;
+      this.#closing = false;
+    }
+    #kernel;
+    #handle;
+    #closing;
+    kill(signal = "SIGTERM") {
+      const name = signalName(signal) ?? "SIGTERM";
+      this.killed = true;
+      if (!this.#kernel) return false;
+      try {
+        const ret = this.#kernel.kill(name);
+        return ret !== false;
+      } catch {
+        return false;
+      }
+    }
+    ref() {
+      if (this.#handle) handles.add(this.#handle);
+      return this;
+    }
+    unref() {
+      if (this.#handle) handles.delete(this.#handle);
+      return this;
+    }
+    /** @internal */
+    _bindKernel(child) {
+      this.#kernel = child;
+      this.pid = child.pid;
+      this.#handle = { kind: "child", pid: child.pid };
+      handles.add(this.#handle);
+    }
+    /** @internal */
+    _release() {
+      if (this.#handle) {
+        handles.delete(this.#handle);
+        this.#handle = null;
+      }
+    }
+    /** @internal */
+    _markClosing() {
+      this.#closing = true;
+    }
+    get _closing() {
+      return this.#closing;
+    }
+  }
+  function createPipeReadable() {
+    const { Readable } = getStream();
+    const r = new Readable({ read() {
+    } });
+    r._sliccPump = async (webStream) => {
+      if (!webStream) {
+        r.push(null);
+        return;
+      }
+      try {
+        const reader = webStream.getReader();
+        for (; ; ) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          const chunk = value instanceof Uint8Array ? Buffer2.from(value) : Buffer2.from(String(value));
+          r.push(chunk);
+        }
+        r.push(null);
+      } catch (err) {
+        r.destroy(err);
+      }
+    };
+    return r;
+  }
+  function createPipeWritable() {
+    const { Writable } = getStream();
+    let writer = null;
+    const pending = [];
+    let ended = false;
+    const w = new Writable({
+      write(chunk, _enc, cb) {
+        const bytes = typeof chunk === "string" ? Buffer2.from(chunk) : chunk;
+        if (!writer) {
+          pending.push({ bytes, cb });
+          return;
+        }
+        writer.write(bytes).then(() => cb(), cb);
+      },
+      final(cb) {
+        ended = true;
+        if (!writer) {
+          pending.push({ end: true, cb });
+          return;
+        }
+        writer.close().then(() => cb(), cb);
+      },
+      destroy(err, cb) {
+        if (writer) writer.abort(err).then(() => cb(err), () => cb(err));
+        else cb(err);
+      }
+    });
+    w._sliccAttach = (webStream) => {
+      if (!webStream) {
+        for (const p of pending) p.cb?.(new Error("stdin not available"));
+        pending.length = 0;
+        return;
+      }
+      writer = webStream.getWriter();
+      for (const p of pending) {
+        if (p.end) writer.close().then(() => p.cb(), p.cb);
+        else writer.write(p.bytes).then(() => p.cb(), p.cb);
+      }
+      pending.length = 0;
+      if (ended && pending.length === 0) {
+      }
+    };
+    return w;
+  }
+  function prepareStdio(child, stdio) {
+    const [inMode, outMode, errMode] = stdio;
+    if (toKernelStdio(inMode) === "pipe") child.stdin = createPipeWritable();
+    if (toKernelStdio(outMode) === "pipe") child.stdout = createPipeReadable();
+    if (toKernelStdio(errMode) === "pipe") child.stderr = createPipeReadable();
+  }
+  function connectStdio(child, kernelChild) {
+    child.stdin?._sliccAttach?.(kernelChild.stdin);
+    const pumps = [];
+    if (child.stdout?._sliccPump) pumps.push(child.stdout._sliccPump(kernelChild.stdout));
+    if (child.stderr?._sliccPump) pumps.push(child.stderr._sliccPump(kernelChild.stderr));
+    child._stdioPumps = Promise.all(pumps);
+  }
+  function finish(child, code, signal) {
+    if (child._closing) return;
+    child._markClosing();
+    child.exitCode = code;
+    child.signalCode = signal;
+    child.emit("exit", code, signal);
+    const after = child._stdioPumps ?? Promise.resolve();
+    trackPromise(handles, after);
+    after.finally(() => {
+      child.emit("close", code, signal);
+      child._release();
+      handles.notify?.();
+    });
+  }
+  function startSpawn(child, file, args, options, stdio) {
+    const cwd = options.cwd != null ? String(options.cwd) : process2.cwd();
+    const env = options.env ? { ...options.env } : { ...process2.env };
+    const argv = [file, ...args];
+    child.spawnfile = file;
+    child.spawnargs = argv;
+    const spawnPromise = ctx.spawn({
+      argv,
+      cwd,
+      env,
+      stdin: toKernelStdio(stdio[0]),
+      stdout: toKernelStdio(stdio[1]),
+      stderr: toKernelStdio(stdio[2])
+    });
+    trackPromise(handles, spawnPromise);
+    spawnPromise.then(
+      (kernelChild) => {
+        child._bindKernel(kernelChild);
+        connectStdio(child, kernelChild);
+        child.emit("spawn");
+        const waitP = kernelChild.wait();
+        trackPromise(handles, waitP);
+        waitP.then(
+          (status) => {
+            const sigNum = status?.signal;
+            if (sigNum != null && sigNum !== 0) {
+              const name = SIGNAL_NAMES[sigNum] ?? String(sigNum);
+              finish(child, null, name);
+            } else {
+              const code = typeof status?.status === "number" ? status.status : 0;
+              finish(child, code, null);
+            }
+          },
+          (err) => {
+            child.emit("error", err);
+            finish(child, 1, null);
+          }
+        );
+      },
+      (err) => {
+        const code = err?.code === "ENOENT" ? "ENOENT" : err?.code ?? "ERR_SPAWN_FAILED";
+        const error = code === "ENOENT" ? spawnError(file, args, "ENOENT", `spawn ${file} ENOENT`) : spawnError(file, args, code, err?.message ?? String(err));
+        try {
+          child.stdout?.push?.(null);
+        } catch {
+        }
+        try {
+          child.stderr?.push?.(null);
+        } catch {
+        }
+        process2.nextTick(() => {
+          child.emit("error", error);
+          if (code === "ENOENT") {
+            child.exitCode = -2;
+            child.emit("close", -2, null);
+          } else {
+            finish(child, 1, null);
+          }
+          child._release();
+          handles.notify?.();
+        });
+      }
+    );
+  }
+  function spawn(command, args, options) {
+    let file = command;
+    let argv = args;
+    let opts = options;
+    if (argv != null && !Array.isArray(argv) && typeof argv === "object") {
+      opts = argv;
+      argv = [];
+    }
+    argv = Array.isArray(argv) ? argv.map(String) : [];
+    opts = opts && typeof opts === "object" ? opts : {};
+    file = String(file);
+    if (opts.shell) {
+      const shell = typeof opts.shell === "string" ? opts.shell : "sh";
+      const line = argv.length ? [file, ...argv].join(" ") : file;
+      file = shell;
+      argv = ["-c", line];
+    }
+    const stdio = normalizeStdio(opts.stdio);
+    const child = new ChildProcess();
+    prepareStdio(child, stdio);
+    process2.nextTick(() => startSpawn(child, file, argv, opts, stdio));
+    return child;
+  }
+  function execFile(file, args, options, callback) {
+    const norm = normalizeArgs(file, args, options, callback);
+    const opts = { ...norm.options };
+    if (opts.stdio === void 0) opts.stdio = ["pipe", "pipe", "pipe"];
+    const child = spawn(String(file), norm.args, opts);
+    if (!norm.callback) return child;
+    const maxBuffer = opts.maxBuffer ?? 1024 * 1024;
+    let stdout = Buffer2.alloc(0);
+    let stderr = Buffer2.alloc(0);
+    let exited = false;
+    const done = (err) => {
+      if (exited) return;
+      exited = true;
+      const enc = opts.encoding;
+      const out = enc ? stdout.toString(enc) : stdout;
+      const errOut = enc ? stderr.toString(enc) : stderr;
+      norm.callback(err, out, errOut);
+    };
+    if (child.stdout) {
+      child.stdout.on("data", (chunk) => {
+        stdout = Buffer2.concat([stdout, Buffer2.isBuffer(chunk) ? chunk : Buffer2.from(chunk)]);
+        if (stdout.length > maxBuffer) {
+          child.kill();
+          const err = new Error("stdout maxBuffer exceeded");
+          err.code = "ERR_CHILD_PROCESS_STDIO_MAXBUFFER";
+          done(err);
+        }
+      });
+    }
+    if (child.stderr) {
+      child.stderr.on("data", (chunk) => {
+        stderr = Buffer2.concat([stderr, Buffer2.isBuffer(chunk) ? chunk : Buffer2.from(chunk)]);
+        if (stderr.length > maxBuffer) {
+          child.kill();
+          const err = new Error("stderr maxBuffer exceeded");
+          err.code = "ERR_CHILD_PROCESS_STDIO_MAXBUFFER";
+          done(err);
+        }
+      });
+    }
+    child.on("error", (err) => done(err));
+    child.on("close", (code, signal) => {
+      if (exited) return;
+      if (code === 0 && !signal) {
+        done(null);
+        return;
+      }
+      const err = new Error(`Command failed: ${file} ${norm.args.join(" ")}`);
+      err.code = code;
+      err.killed = child.killed;
+      err.signal = signal;
+      err.cmd = `${file} ${norm.args.join(" ")}`.trim();
+      err.stdout = opts.encoding ? stdout.toString(opts.encoding) : stdout;
+      err.stderr = opts.encoding ? stderr.toString(opts.encoding) : stderr;
+      done(err);
+    });
+    return child;
+  }
+  function exec(command, options, callback) {
+    let opts = options;
+    let cb = callback;
+    if (typeof options === "function") {
+      cb = options;
+      opts = {};
+    }
+    opts = opts && typeof opts === "object" ? opts : {};
+    const shell = typeof opts.shell === "string" ? opts.shell : "sh";
+    return execFile(shell, ["-c", String(command)], { ...opts, shell: false }, cb);
+  }
+  return {
+    spawn,
+    execFile,
+    exec,
+    spawnSync() {
+      notSupported("spawnSync");
+    },
+    execSync() {
+      notSupported("execSync");
+    },
+    execFileSync() {
+      notSupported("execFileSync");
+    },
+    fork() {
+      notSupported("fork");
+    },
+    ChildProcess,
+    // Expose for tests / advanced callers
+    _SIGNAL_NAMES: SIGNAL_NAMES,
+    _SIGNAL_NUMBERS: SIGNAL_NUMBERS
+  };
+}
+
 // src/runtime/builtins/fs.mjs
-var encoder2 = new TextEncoder();
-var decoder2 = new TextDecoder();
+var encoder3 = new TextEncoder();
+var decoder3 = new TextDecoder();
 var ERRNO = {
   ENOENT: -2,
   EEXIST: -17,
@@ -9894,10 +11249,10 @@ function nodeFsError(code, syscall, pathArg, err, dest) {
   return e;
 }
 function toBytes(data2) {
-  if (typeof data2 === "string") return encoder2.encode(data2);
+  if (typeof data2 === "string") return encoder3.encode(data2);
   if (data2 instanceof Uint8Array) return data2;
   if (ArrayBuffer.isView(data2)) return new Uint8Array(data2.buffer, data2.byteOffset, data2.byteLength);
-  return encoder2.encode(String(data2));
+  return encoder3.encode(String(data2));
 }
 function statView(st) {
   const mtimeMs = st.mtimeMs ?? (st.mtime ? Number(st.mtime) : 0);
@@ -9958,7 +11313,7 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
   const track = (p) => handles ? trackPromise(handles, p) : p;
   const fdTable = /* @__PURE__ */ new Map();
   let nextFd = 3;
-  function parseFlags(flags) {
+  function parseFlags2(flags) {
     const f = flags == null ? "r" : String(flags);
     const readable = f.includes("r") || f === "a+" || f === "w+" || f === "ax+" || f === "wx+";
     const writable = f.includes("w") || f.includes("a") || f === "r+" || f === "rs+" || f === "as+" || f === "wx" || f === "ax";
@@ -10081,11 +11436,11 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
     try {
       if (typeof process2?._readStdinSync === "function") {
         const out = process2._readStdinSync();
-        return encoding ? decoder2.decode(out) : wrapBuffer(out);
+        return encoding ? decoder3.decode(out) : wrapBuffer(out);
       }
       if (typeof process2?.stdin?._readAllSync === "function") {
         const out = process2.stdin._readAllSync();
-        return encoding ? decoder2.decode(out) : wrapBuffer(out);
+        return encoding ? decoder3.decode(out) : wrapBuffer(out);
       }
       if (typeof ctx.sync?.read === "function") {
         const chunks = [];
@@ -10102,7 +11457,7 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
           out.set(c, at2);
           at2 += c.length;
         }
-        return encoding ? decoder2.decode(out) : wrapBuffer(out);
+        return encoding ? decoder3.decode(out) : wrapBuffer(out);
       }
     } catch {
     }
@@ -10174,7 +11529,7 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
           throw e;
         }
         const bytes = syncFs.readFile(target);
-        if (encoding) return decoder2.decode(bytes);
+        if (encoding) return decoder3.decode(bytes);
         return wrapBuffer(bytes);
       } catch (err) {
         if (err?.code && err.syscall) throw err;
@@ -10241,6 +11596,21 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
         throw nodeFsError(err?.code || "ENOENT", "lstat", pathArg, err);
       }
     },
+    /**
+     * Resolve to a canonical absolute path. Symlink walk is not implemented;
+     * when the path exists we return the normalized absolute form (enough for
+     * pnpm's cmd shims, which only need dirname(realpathSync(argv[1]))).
+     */
+    realpathSync(p) {
+      const pathArg = p;
+      const target = abs(p);
+      try {
+        syncFs.stat(target);
+        return target;
+      } catch (err) {
+        throw nodeFsError(err?.code || "ENOENT", "realpath", pathArg, err);
+      }
+    },
     readdirSync,
     mkdirSync,
     rmdirSync(p, options = {}) {
@@ -10297,7 +11667,7 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
       if (pathArg === "/dev/stdin" || pathArg === "/dev/fd/0") {
         return 0;
       }
-      const fl = parseFlags(flags);
+      const fl = parseFlags2(flags);
       const target = abs(p);
       const exists = syncFs.exists(target);
       if (fl.exclusive && exists) throw nodeFsError("EEXIST", "open", pathArg);
@@ -10342,7 +11712,7 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
       );
       if (fd === 0) {
         const data2 = readStdinSync(null);
-        const src = data2 instanceof Uint8Array ? data2 : encoder2.encode(String(data2));
+        const src = data2 instanceof Uint8Array ? data2 : encoder3.encode(String(data2));
         const n = Math.min(len, src.length);
         buffer.set(src.subarray(0, n), bufOffset);
         return n;
@@ -10465,7 +11835,7 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
           const encoding = typeof options === "string" ? options : options?.encoding;
           try {
             const bytes = await asyncFs.readFile(abs(p));
-            if (encoding) return decoder2.decode(bytes);
+            if (encoding) return decoder3.decode(bytes);
             return wrapBuffer(bytes);
           } catch (err) {
             throw nodeFsError(err?.code || "ENOENT", "open", p, err);
@@ -10879,6 +12249,7 @@ function createFs({ ctx, path, process: process2, Buffer: Buffer2, handles, getS
     access: callbackify(syncApi.accessSync),
     stat: callbackify(syncApi.statSync),
     lstat: callbackify(syncApi.lstatSync),
+    realpath: callbackify(syncApi.realpathSync),
     readdir: callbackify(syncApi.readdirSync),
     mkdir: callbackify(syncApi.mkdirSync),
     rmdir: callbackify(syncApi.rmdirSync),
@@ -11049,7 +12420,7 @@ function responseHasNoBody(method, statusCode) {
   if (statusCode >= 100 && statusCode < 200) return true;
   return false;
 }
-function createHttp({ ctx, process: process2, Buffer: Buffer2, handles, getStream, net }) {
+function createHttp2({ ctx, process: process2, Buffer: Buffer2, handles, getStream, net }) {
   void ctx;
   void process2;
   const stream = getStream();
@@ -11739,7 +13110,7 @@ function createHttp({ ctx, process: process2, Buffer: Buffer2, handles, getStrea
 
 // src/runtime/builtins/https.mjs
 var TLS_CLIENT_OPTS = ["cert", "key", "pfx", "ca"];
-function notSupported(what) {
+function notSupported2(what) {
   const err = new Error(`slicc-jsh: '${what}' is not supported yet (no TLS on ctx.net)`);
   err.code = "ERR_NOT_SUPPORTED";
   return err;
@@ -11753,7 +13124,7 @@ function isManualRedirectUnsupported(err) {
 function rejectTlsOptions(options) {
   for (const name of TLS_CLIENT_OPTS) {
     if (options?.[name] != null) {
-      throw notSupported(`https.request option '${name}'`);
+      throw notSupported2(`https.request option '${name}'`);
     }
   }
 }
@@ -11787,7 +13158,7 @@ function createHttps({ ctx, Buffer: Buffer2, http, handles }) {
     }
   }
   function createServer() {
-    throw notSupported("https.createServer");
+    throw notSupported2("https.createServer");
   }
   class ClientRequest extends EventEmitter {
     #ended = false;
@@ -11878,7 +13249,7 @@ function createHttps({ ctx, Buffer: Buffer2, http, handles }) {
       if (this.#sent || this.#destroyed) return;
       this.#sent = true;
       try {
-        if (typeof ctx.fetch !== "function") throw notSupported("https.request");
+        if (typeof ctx.fetch !== "function") throw notSupported2("https.request");
         const opts = this.#opts;
         const method = (opts.method ?? "GET").toUpperCase();
         const host = opts.hostname ?? opts.host ?? "localhost";
@@ -12499,7 +13870,7 @@ function createQuerystring() {
 }
 
 // src/runtime/vendor-load.mjs
-var decoder3 = new TextDecoder();
+var decoder4 = new TextDecoder();
 var cache = /* @__PURE__ */ new Map();
 function evalCjs(source, filename) {
   const module = { exports: {} };
@@ -12515,7 +13886,7 @@ function loadVendorCjs({ ctx, packageRoot, name, globals = {} }) {
   if (cache.has(key)) return cache.get(key);
   const path = `${packageRoot}/dist/vendor/${name}.cjs`;
   const bytes = ctx.sync.fs.readFile(path);
-  const source = typeof bytes === "string" ? bytes : decoder3.decode(bytes);
+  const source = typeof bytes === "string" ? bytes : decoder4.decode(bytes);
   const saved = {};
   for (const [k, v] of Object.entries(globals)) {
     saved[k] = globalThis[k];
@@ -12767,6 +14138,7 @@ var BUILTIN_LIST = [
   "assert",
   "assert/strict",
   "buffer",
+  "child_process",
   "console",
   "events",
   "fs",
@@ -12790,7 +14162,6 @@ var BUILTIN_LIST = [
   "util/types"
 ];
 var NOT_YET = [
-  "child_process",
   "http2",
   "crypto",
   "zlib",
@@ -12809,7 +14180,7 @@ var NOT_YET = [
   "v8",
   "was"
 ];
-function notSupported2(id) {
+function notSupported3(id) {
   const err = new Error(`slicc-jsh: '${id}' is not supported yet`);
   err.code = "ERR_NOT_SUPPORTED";
   throw err;
@@ -12847,7 +14218,7 @@ function createBuiltins({ ctx, process: process2, Buffer: Buffer2, console: cons
   };
   let http;
   const getHttp = () => {
-    if (!http) http = createHttp({ ctx, process: process2, Buffer: Buffer2, handles, getStream, net: getNet() });
+    if (!http) http = createHttp2({ ctx, process: process2, Buffer: Buffer2, handles, getStream, net: getNet() });
     return http;
   };
   let https;
@@ -12855,6 +14226,13 @@ function createBuiltins({ ctx, process: process2, Buffer: Buffer2, console: cons
     if (!https) https = createHttps({ ctx, Buffer: Buffer2, http: getHttp(), handles });
     return https;
   };
+  let childProcess;
+  const getChildProcess = () => {
+    if (!childProcess) {
+      childProcess = createChildProcess({ ctx, process: process2, Buffer: Buffer2, handles, getStream });
+    }
+    return childProcess;
+  };
   let ModuleExport = null;
   const implemented = {
     process: () => process2,
@@ -12880,7 +14258,8 @@ function createBuiltins({ ctx, process: process2, Buffer: Buffer2, console: cons
     "timers/promises": () => timersPromises,
     net: () => getNet(),
     http: () => getHttp(),
-    https: () => getHttps()
+    https: () => getHttps(),
+    child_process: () => getChildProcess()
   };
   return {
     installModule(Module) {
@@ -12894,7 +14273,7 @@ function createBuiltins({ ctx, process: process2, Buffer: Buffer2, console: cons
     },
     load(id) {
       const bare = id.startsWith("node:") ? id.slice(5) : id;
-      if (NOT_YET.includes(bare)) notSupported2(bare);
+      if (NOT_YET.includes(bare)) notSupported3(bare);
       const factory = implemented[bare];
       if (!factory) {
         const err = new Error(`No such built-in module: ${id}`);
@@ -13201,7 +14580,7 @@ function isBuiltinName(name) {
 }
 
 // src/runtime/cjs/loader.mjs
-var decoder4 = new TextDecoder();
+var decoder5 = new TextDecoder();
 function createCjs({
   ctx,
   process: process2,
@@ -13218,7 +14597,7 @@ function createCjs({
   const readPackageJson = (pkgPath) => {
     if (packageCache.has(pkgPath)) return packageCache.get(pkgPath);
     try {
-      const text = decoder4.decode(fs.readFile(pkgPath));
+      const text = decoder5.decode(fs.readFile(pkgPath));
       const pkg = JSON.parse(text);
       packageCache.set(pkgPath, pkg);
       return pkg;
@@ -13305,14 +14684,14 @@ function createCjs({
   };
   Module._extensions = {
     ".js"(module, filename) {
-      const source = decoder4.decode(fs.readFile(filename));
+      const source = decoder5.decode(fs.readFile(filename));
       compile(module, source, filename);
     },
     ".cjs"(module, filename) {
       Module._extensions[".js"](module, filename);
     },
     ".json"(module, filename) {
-      module.exports = JSON.parse(decoder4.decode(fs.readFile(filename)));
+      module.exports = JSON.parse(decoder5.decode(fs.readFile(filename)));
     }
   };
   Module.Module = Module;
@@ -13703,7 +15082,7 @@ function renderTable(tabularData, util2) {
     });
   }
   const widths = headers.map(
-    (h, col) => Math.max(h.length, ...rows.map((r) => (r[col] ?? "").length))
+    (h, col2) => Math.max(h.length, ...rows.map((r) => (r[col2] ?? "").length))
   );
   const pad = (s, w) => s + " ".repeat(Math.max(0, w - s.length));
   const line = (left, mid, right, fill) => left + widths.map((w) => fill.repeat(w + 2)).join(mid) + right;
@@ -13796,7 +15175,7 @@ function createConsole(writeStdout, writeStderr, util2) {
 }
 
 // src/runtime/esm/loader.mjs
-var decoder5 = new TextDecoder();
+var decoder6 = new TextDecoder();
 var IMPORT_CONDITIONS = ["slicc", "import", "node", "default"];
 function pathToFileURL2(filename) {
   if (filename.startsWith("file:")) return filename;
@@ -13840,7 +15219,7 @@ function createEsm({ ctx, process: process2, handles, builtins, cjs, trackPromis
   const readPackageJson = (pkgPath) => {
     if (packageCache.has(pkgPath)) return packageCache.get(pkgPath);
     try {
-      const pkg = JSON.parse(decoder5.decode(fs.readFile(pkgPath)));
+      const pkg = JSON.parse(decoder6.decode(fs.readFile(pkgPath)));
       packageCache.set(pkgPath, pkg);
       return pkg;
     } catch {
@@ -13979,7 +15358,7 @@ ${code}`
           await importModule(spec, filename);
         }
       };
-      const AsyncFunction = Object.getPrototypeOf(async function() {
+      const AsyncFunction2 = Object.getPrototypeOf(async function() {
       }).constructor;
       const parts = [
         ...exportSetup,
@@ -13988,7 +15367,7 @@ ${code}`
         bodyCode,
         `//# sourceURL=${filename}`
       ];
-      const fn = new AsyncFunction(
+      const fn = new AsyncFunction2(
         "__meta",
         "__importSync",
         "__import",
@@ -14008,13 +15387,13 @@ ${parts.join("\n")}`
   }
   function loadFileSync(filename) {
     if (filename.endsWith(".json")) {
-      const data2 = JSON.parse(decoder5.decode(fs.readFile(filename)));
+      const data2 = JSON.parse(decoder6.decode(fs.readFile(filename)));
       return cjsToNamespace(data2);
     }
     const cached3 = cache2.get(filename);
     if (cached3?.namespace) return cached3.namespace;
     if (cached3?.evaluating) return cached3.exportsObj;
-    const source = decoder5.decode(fs.readFile(filename));
+    const source = decoder6.decode(fs.readFile(filename));
     if (!isEsmFilename(filename, source)) {
       const exports = cjs.loadFile(filename);
       const ns = cjsToNamespace(exports);
@@ -14025,14 +15404,14 @@ ${parts.join("\n")}`
   }
   async function loadFileAsync(filename) {
     if (filename.endsWith(".json")) {
-      const data2 = JSON.parse(decoder5.decode(fs.readFile(filename)));
+      const data2 = JSON.parse(decoder6.decode(fs.readFile(filename)));
       return cjsToNamespace(data2);
     }
     const cached3 = cache2.get(filename);
     if (cached3?.namespace) return cached3.namespace;
     if (cached3?.evaluating && evaluatingStack.has(filename)) return cached3.exportsObj;
     if (cached3?.promise) return cached3.promise;
-    const source = decoder5.decode(fs.readFile(filename));
+    const source = decoder6.decode(fs.readFile(filename));
     if (!isEsmFilename(filename, source)) {
       const exports = cjs.loadFile(filename);
       const ns = cjsToNamespace(exports);
@@ -14065,7 +15444,7 @@ ${parts.join("\n")}`
     return ns;
   }
   function runMain(filename, source) {
-    const src = source ?? decoder5.decode(fs.readFile(filename));
+    const src = source ?? decoder6.decode(fs.readFile(filename));
     if (!isEsmFilename(filename, src)) {
       return cjs.runMain(filename, src);
     }
@@ -14090,7 +15469,7 @@ ${parts.join("\n")}`
     const cached3 = cache2.get(filename);
     if (cached3?.namespace) return cached3.namespace;
     if (cached3?.evaluating) return cached3.exportsObj;
-    const source = decoder5.decode(fs.readFile(filename));
+    const source = decoder6.decode(fs.readFile(filename));
     const { hasTopLevelAwait } = transformEsm(source, filename);
     if (hasTopLevelAwait) {
       const err = new Error(
@@ -14180,7 +15559,7 @@ function wrapCallSite(frame) {
   const file = resolveFile(frame, parsed);
   const rawLine = frame.getLineNumber?.() ?? parsed?.line;
   const line = adjustLine(rawLine);
-  const col = frame.getColumnNumber?.() ?? parsed?.column ?? 0;
+  const col2 = frame.getColumnNumber?.() ?? parsed?.column ?? 0;
   const method = frame.getMethodName?.();
   const typeName = frame.getTypeName?.();
   const userName = frame.getFunctionName?.();
@@ -14229,7 +15608,7 @@ function wrapCallSite(frame) {
     getMethodName: () => method,
     getFileName: () => file,
     getLineNumber: () => line,
-    getColumnNumber: () => col,
+    getColumnNumber: () => col2,
     getEvalOrigin: () => frame.getEvalOrigin?.(),
     isToplevel: () => !!isToplevel,
     isEval: () => frame.isEval?.() ?? false,
@@ -14240,7 +15619,7 @@ function wrapCallSite(frame) {
     getPromiseIndex: () => frame.getPromiseIndex?.(),
     toString() {
       const f = file || "unknown";
-      const pos = line != null ? `:${line}:${col ?? 0}` : "";
+      const pos = line != null ? `:${line}:${col2 ?? 0}` : "";
       const label = fn || "Object.<anonymous>";
       if (f === "[eval]" || String(f).includes("[eval]")) {
         if (label === "Object.<anonymous>") return `${f}${pos}`;
@@ -14317,20 +15696,20 @@ function snippetFor(ctx, loc, evalCode) {
   const n = loc.line >= 1 && loc.line <= lines.length ? loc.line : 1;
   const text = lines[n - 1];
   if (text === void 0) return null;
-  let col = loc.column;
+  let col2 = loc.column;
   const throwAt = text.search(/\bthrow\b/);
   const isAsyncLine = /\basync\b/.test(text);
   if (loc.file === "[eval]" && throwAt === 0) {
-    col = 1;
+    col2 = 1;
   } else if (throwAt >= 0 && isAsyncLine && /\bthrow\s+new\b/.test(text)) {
-    col = text.indexOf("new", throwAt) + 1;
+    col2 = text.indexOf("new", throwAt) + 1;
   } else if (throwAt >= 0) {
-    col = throwAt + 1;
-  } else if (!(col >= 1)) {
-    col = 1;
+    col2 = throwAt + 1;
+  } else if (!(col2 >= 1)) {
+    col2 = 1;
   }
-  col = Math.min(Math.max(1, col), Math.max(1, text.length + 1));
-  return { file: loc.file, lineNo: n, text, caret: `${" ".repeat(col - 1)}^` };
+  col2 = Math.min(Math.max(1, col2), Math.max(1, text.length + 1));
+  return { file: loc.file, lineNo: n, text, caret: `${" ".repeat(col2 - 1)}^` };
 }
 function assertionHeader(err) {
   const msg = err.message || "";
@@ -14573,52 +15952,6 @@ UnhandledPromiseRejection: ${msg} {
   return { body: body + trailer };
 }
 
-// src/runtime/exit.mjs
-var NodeExitError = class extends Error {
-  constructor(code) {
-    super(`Process exited with code ${code}`);
-    this.name = "NodeExitError";
-    this.code = code;
-  }
-};
-function numericExitCode(value) {
-  const n = Number(value);
-  return Number.isFinite(n) ? n & 255 : 0;
-}
-function describeReceived(value) {
-  if (typeof value === "string") return `type string ('${value}')`;
-  if (typeof value === "boolean") return `type boolean (${value})`;
-  if (typeof value === "bigint") return `type bigint (${value}n)`;
-  if (Array.isArray(value)) return "an instance of Array";
-  if (typeof value === "object" && value !== null) return "an instance of Object";
-  return `type ${typeof value}`;
-}
-function assignProcessExitCode(value) {
-  if (value === null || value === void 0) return void 0;
-  if (typeof value === "string") {
-    const n = Number(value);
-    if (value !== "" && Number.isInteger(n)) return n === 0 ? 0 : n;
-    const err2 = new TypeError(
-      `The "code" argument must be of type number. Received ${describeReceived(value)}`
-    );
-    err2.code = "ERR_INVALID_ARG_TYPE";
-    throw err2;
-  }
-  if (typeof value === "number") {
-    if (Number.isInteger(value)) return value === 0 ? 0 : value;
-    const err2 = new RangeError(
-      `The value of "code" is out of range. It must be an integer. Received ${String(value)}`
-    );
-    err2.code = "ERR_OUT_OF_RANGE";
-    throw err2;
-  }
-  const err = new TypeError(
-    `The "code" argument must be of type number. Received ${describeReceived(value)}`
-  );
-  err.code = "ERR_INVALID_ARG_TYPE";
-  throw err;
-}
-
 // src/runtime/handles.mjs
 function createHandleTable() {
   const refed = /* @__PURE__ */ new Set();
@@ -14737,7 +16070,7 @@ function createStdin(ctx, handles, Buffer2) {
   let encoding = null;
   let ended = false;
   let started = false;
-  const decoder7 = new TextDecoder();
+  const decoder8 = new TextDecoder();
   const collected = [];
   let collectDone = false;
   const emitChunk = (bytes) => {
@@ -14745,7 +16078,7 @@ function createStdin(ctx, handles, Buffer2) {
     const u8 = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
     collected.push(u8);
     const chunk = Buffer2 ? Buffer2.from(u8) : u8;
-    const data2 = encoding === "utf8" || encoding === "utf-8" ? decoder7.decode(chunk) : encoding ? chunk.toString?.(encoding) ?? decoder7.decode(chunk) : chunk;
+    const data2 = encoding === "utf8" || encoding === "utf-8" ? decoder8.decode(chunk) : encoding ? chunk.toString?.(encoding) ?? decoder8.decode(chunk) : chunk;
     ee.emit("data", data2);
   };
   const finish = () => {
@@ -14992,6 +16325,42 @@ var Process = class extends EventEmitter {
   cwd() {
     return this._cwd;
   }
+  /** Root (0) until credential plumbing is exposed on process. */
+  getuid() {
+    return 0;
+  }
+  geteuid() {
+    return 0;
+  }
+  getgid() {
+    return 0;
+  }
+  getegid() {
+    return 0;
+  }
+  getgroups() {
+    return [0];
+  }
+  /**
+   * Minimal process.kill: only this process (pid === this.pid). Used by pnpm
+   * cmd shims to re-raise a child's terminating signal. Unknown pids → ESRCH.
+   */
+  kill(pid, signal = "SIGTERM") {
+    const target = Number(pid);
+    if (target !== this.pid) {
+      const err = new Error(`kill ESRCH`);
+      err.code = "ESRCH";
+      err.errno = -3;
+      err.syscall = "kill";
+      throw err;
+    }
+    const name = typeof signal === "string" ? signal.startsWith("SIG") ? signal : `SIG${signal}` : "SIGTERM";
+    if (name === "SIGTERM" || name === "SIGINT" || name === "SIGHUP" || name === "SIGKILL") {
+      const codes = { SIGTERM: 143, SIGINT: 130, SIGHUP: 129, SIGKILL: 137 };
+      this.exit(codes[name] ?? 1);
+    }
+    return true;
+  }
   chdir(path) {
     if (typeof path !== "string") {
       const err = new TypeError(
@@ -15460,7 +16829,7 @@ function createWebSocket(ctx, { handles, trackPromise: trackPromise2 } = {}) {
 }
 
 // src/runtime/run.mjs
-var decoder6 = new TextDecoder();
+var decoder7 = new TextDecoder();
 function installJshGlobals(bindings) {
   const saved = /* @__PURE__ */ new Map();
   for (const name of Object.keys(bindings)) {
@@ -15499,6 +16868,8 @@ async function runNode(ctx, options = {}) {
   let lastEvalCode;
   let restoreGlobals = () => {
   };
+  let removeJshHandoff = () => {
+  };
   const removeCtxHooks = [];
   const util2 = createUtil();
   const printUncaught = (err) => {
@@ -15718,17 +17089,19 @@ slicc-jsh ${NODE_SHIM_VERSION} (Node-compatible, abi: js)
   cjs.setRequireEsmHook((filename) => esm.requireEsm(filename));
   cjs.setImportModuleHook((specifier, parent) => esm.importModule(specifier, parent));
   try {
+    const rt = {
+      process: process2,
+      console: console2,
+      Buffer: Buffer2,
+      fetch,
+      createRequire: cjs.createRequire,
+      importModule: (specifier, parent) => esm.importModule(specifier, parent),
+      rewriteDynamicImports
+    };
+    removeJshHandoff = installJshHandoff(ctx, rt);
     if (typeof options.main === "function") {
       try {
-        const result = options.main({
-          process: process2,
-          console: console2,
-          Buffer: Buffer2,
-          fetch,
-          createRequire: cjs.createRequire,
-          importModule: (specifier, parent) => esm.importModule(specifier, parent),
-          rewriteDynamicImports
-        });
+        const result = options.main(rt);
         if (result != null && typeof result.then === "function") {
           trackPromise(handles, result).catch(() => {
           });
@@ -15776,7 +17149,7 @@ slicc-jsh ${NODE_SHIM_VERSION} (Node-compatible, abi: js)
         merged.set(c, off);
         off += c.byteLength;
       }
-      const source = decoder6.decode(merged);
+      const source = decoder7.decode(merged);
       lastEvalCode = source;
       process2._evalCode = source;
       process2.argv[1] = "[stdin]";
@@ -15859,7 +17232,7 @@ slicc-jsh ${NODE_SHIM_VERSION} (Node-compatible, abi: js)
       const filePath = ctx.resolve(parsed.script);
       let source;
       try {
-        source = decoder6.decode(ctx.sync.fs.readFile(filePath));
+        source = decoder7.decode(ctx.sync.fs.readFile(filePath));
       } catch (err) {
         const msg = err?.message ?? String(err);
         await ctx.write(2, `${ctx.argv[0]}: cannot open ${parsed.script}: ${msg}
@@ -15948,6 +17321,7 @@ slicc-jsh ${NODE_SHIM_VERSION} (Node-compatible, abi: js)
     }
     try {
       restoreGlobals();
+      removeJshHandoff();
     } catch {
     }
   }