@ai-ecoverse/slicc-jsh 0.2.0 → 0.3.0

package/dist/jsh.mjs

@@ -1536,10 +1536,56 @@ ${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.2.0",
+  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",
@@ -1560,8 +1606,13 @@ var package_default = {
   },
   publishConfig: {
     access: "public",
-    provenance: true,
-    tag: "latest"
+    provenance: true
+  },
+  fledgling: {
+    provider: "github",
+    workflow: "release.yml",
+    repo: "ai-ecoverse/slicc-jsh",
+    publish: true
   },
   files: [
     "LICENSE",
@@ -1598,16 +1649,21 @@ var package_default = {
     "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"
+    "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.56.2",
+    "@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"
   }
@@ -2275,50 +2331,155 @@ async function runJsh({ filename, engine, process: process2, console: console2 }
   return void 0;
 }
 
-// src/runtime/exit.mjs
-var NodeExitError = class extends Error {
-  constructor(code) {
-    super(`Process exited with code ${code}`);
-    this.name = "NodeExitError";
-    this.code = code;
+// 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;
   }
-};
-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}`;
+  const out = new Uint8Array(size);
+  let off = 0;
+  for (const c of chunks) {
+    out.set(c, off);
+    off += c.length;
+  }
+  return out;
 }
-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;
+async function writeAll(stream, data2) {
+  const writer = stream.getWriter();
+  try {
+    await writer.write(typeof data2 === "string" ? encoder.encode(data2) : data2);
+    await writer.close();
+  } catch {
   }
-  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)}`
+}
+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}
+})`
     );
-    err2.code = "ERR_OUT_OF_RANGE";
-    throw err2;
+    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 () => {
+    };
   }
-  const err = new TypeError(
-    `The "code" argument must be of type number. Received ${describeReceived(value)}`
-  );
-  err.code = "ERR_INVALID_ARG_TYPE";
-  throw err;
+  return () => {
+    try {
+      delete globalThis[JSH_HANDOFF];
+    } catch {
+    }
+  };
 }
 
 // src/runtime/async-handles.mjs
@@ -2377,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";
@@ -2450,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)) {
@@ -2458,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);
@@ -2482,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);
@@ -10632,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,
@@ -10679,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);
@@ -10866,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 = [];
@@ -10887,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 {
     }
@@ -10959,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;
@@ -11026,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 = {}) {
@@ -11127,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;
@@ -11250,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);
@@ -11664,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),
@@ -12524,7 +13110,7 @@ function createHttp2({ ctx, process: process2, Buffer: Buffer2, handles, getStre
 
 // 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;
@@ -12538,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}'`);
     }
   }
 }
@@ -12572,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;
@@ -12663,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";
@@ -13284,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: {} };
@@ -13300,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];
@@ -13552,6 +14138,7 @@ var BUILTIN_LIST = [
   "assert",
   "assert/strict",
   "buffer",
+  "child_process",
   "console",
   "events",
   "fs",
@@ -13575,7 +14162,6 @@ var BUILTIN_LIST = [
   "util/types"
 ];
 var NOT_YET = [
-  "child_process",
   "http2",
   "crypto",
   "zlib",
@@ -13594,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;
@@ -13640,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,
@@ -13665,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) {
@@ -13679,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}`);
@@ -13986,7 +14580,7 @@ function isBuiltinName(name) {
 }
 
 // src/runtime/cjs/loader.mjs
-var decoder4 = new TextDecoder();
+var decoder5 = new TextDecoder();
 function createCjs({
   ctx,
   process: process2,
@@ -14003,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;
@@ -14090,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;
@@ -14581,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;
@@ -14625,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 {
@@ -14793,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);
@@ -14810,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);
@@ -14850,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);
     }
@@ -14875,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(
@@ -15731,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(
@@ -16199,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)) {
@@ -16238,6 +16868,8 @@ async function runNode(ctx, options = {}) {
   let lastEvalCode;
   let restoreGlobals = () => {
   };
+  let removeJshHandoff = () => {
+  };
   const removeCtxHooks = [];
   const util2 = createUtil();
   const printUncaught = (err) => {
@@ -16457,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(() => {
           });
@@ -16515,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]";
@@ -16598,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}
@@ -16687,95 +17321,13 @@ slicc-jsh ${NODE_SHIM_VERSION} (Node-compatible, abi: js)
     }
     try {
       restoreGlobals();
+      removeJshHandoff();
     } catch {
     }
   }
 }
 
 // src/jsh.mjs
-var decoder7 = new TextDecoder();
-var encoder3 = 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" ? encoder3.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" ? encoder3.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: decoder7.decode(out), stderr: decoder7.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 main(ctx) {
   const parsed = parseJshArgv([...ctx.argv].slice(1));
   if (parsed.action === "version") {
@@ -16801,32 +17353,7 @@ ${JSH_USAGE}`);
   const nodeCtx = Object.create(ctx, {
     argv: { value: [argv0, filename, ...parsed.args], enumerable: true }
   });
-  return runNode(nodeCtx, {
-    main: async (rt) => {
-      const { process: process2, console: console2 } = rt;
-      let stdoutIsTTY = false;
-      try {
-        stdoutIsTTY = !!await ctx.isatty?.(1);
-      } catch {
-        stdoutIsTTY = false;
-      }
-      const engine = {
-        readSource: (path) => decoder7.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 });
-    }
-  });
+  return runNode(nodeCtx, { main: (rt) => runKernelJsh(ctx, rt, filename) });
 }
 export {
   main as default