@ai-ecoverse/slicc-jsh 0.3.3 → 0.3.5

package/dist/node.mjs

@@ -1536,56 +1536,10 @@ ${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.3",
+  version: "0.3.5",
   description: "Node.js-compatible runtime for slicc-kernel: the node and jsh commands (abi: js)",
   type: "module",
   license: "Apache-2.0",
@@ -1655,7 +1609,7 @@ var package_default = {
     "trust:dry": "npx fledgling sync --dry-run -y --skip-publish"
   },
   devDependencies: {
-    "@ai-ecoverse/slicc-kernel": "1.61.0",
+    "@ai-ecoverse/slicc-kernel": "1.63.0",
     "@ai-ecoverse/wasi-pnpm": "12.9.1-8",
     "abort-controller": "3.0.0",
     acorn: "8.19.0",
@@ -2318,16 +2272,12 @@ async function runJsh({ filename, engine, process: process2, console: console2 }
   const baseRequire = engine.createRequire(filename);
   const requireSliccy = createSliccyResolver({ engine, process: process2, require: baseRequire });
   const require2 = wrapRequire(baseRequire, requireSliccy, module);
-  try {
+  const body = (async () => {
     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);
-  }
+  })();
+  engine.started?.(body);
   return void 0;
 }
 
@@ -2365,7 +2315,7 @@ async function writeAll(stream, data2) {
   } catch {
   }
 }
-function kernelSpawn(ctx, process2) {
+function kernelSpawn(ctx, process2, track) {
   return (argv, { stdin } = {}) => {
     let child = null;
     const done = (async () => {
@@ -2396,7 +2346,7 @@ function kernelSpawn(ctx, process2) {
     })();
     return {
       kill: async (sig = "SIGTERM") => child ? child.kill(sig) : false,
-      done
+      done: track(done)
     };
   };
 }
@@ -2420,7 +2370,7 @@ async function runKernelJsh(ctx, rt, filename) {
   const { process: process2, console: console2 } = rt;
   let stdoutIsTTY = false;
   try {
-    stdoutIsTTY = !!await ctx.isatty?.(1);
+    stdoutIsTTY = !!await rt.track(Promise.resolve(ctx.isatty?.(1)));
   } catch {
     stdoutIsTTY = false;
   }
@@ -2432,11 +2382,11 @@ async function runKernelJsh(ctx, rt, filename) {
     writeStdout: (s) => process2.stdout.write(String(s)),
     writeStderr: (s) => process2.stderr.write(String(s)),
     stdoutIsTTY,
-    spawn: kernelSpawn(ctx, process2),
+    spawn: kernelSpawn(ctx, process2, rt.track),
     shell: ["sh", "-c"],
     fetch: rt.fetch,
-    isExit: (err) => err instanceof NodeExitError,
-    exit: (code) => process2.exit(code)
+    exit: (code) => process2.exit(code),
+    started: (body) => rt.setEntry(body, "jsh")
   };
   await runJsh({ filename, engine, process: process2, console: console2 });
 }
@@ -2517,7 +2467,14 @@ async function checkpoint(nextTick) {
     if (idle >= 6) break;
   }
 }
-async function drainLoop(handles, nextTick, { onBeforeExit, shouldStop } = {}) {
+var nativeSetTimeout = globalThis.setTimeout.bind(globalThis);
+var ENTRY_GRACE_TURNS = 8;
+function macrotask() {
+  return new Promise((resolve2) => {
+    nativeSetTimeout(resolve2, 0);
+  });
+}
+async function drainLoop(handles, nextTick, { onBeforeExit, shouldStop, weakPending } = {}) {
   for (; ; ) {
     await checkpoint(nextTick);
     if (shouldStop?.()) return;
@@ -2527,6 +2484,15 @@ async function drainLoop(handles, nextTick, { onBeforeExit, shouldStop } = {}) {
       await checkpoint(nextTick);
       continue;
     }
+    if (weakPending?.()) {
+      for (let i2 = 0; i2 < ENTRY_GRACE_TURNS; i2++) {
+        await macrotask();
+        await checkpoint(nextTick);
+        if (shouldStop?.() || handles.refCount > 0 || !weakPending()) break;
+      }
+      if (shouldStop?.()) return;
+      if (handles.refCount > 0 || !weakPending()) continue;
+    }
     if (onBeforeExit) {
       onBeforeExit();
       await checkpoint(nextTick);
@@ -15618,20 +15584,12 @@ ${parts.join("\n")}`
       return cjs.runMain(filename, src);
     }
     const { hasTopLevelAwait } = transformEsm(src, filename);
-    if (hasTopLevelAwait) {
-      const p = evaluateEsmAsync(filename, src);
-      if (trackPromise2 && handles) trackPromise2(handles, p);
-      return p;
-    }
+    if (hasTopLevelAwait) return evaluateEsmAsync(filename, src);
     return evaluateEsm(filename, src);
   }
   function runEsmEval(code, filename = "[eval]") {
     const { hasTopLevelAwait } = transformEsm(code, filename);
-    if (hasTopLevelAwait) {
-      const p = evaluateEsmAsync(filename, code);
-      if (trackPromise2 && handles) trackPromise2(handles, p);
-      return p;
-    }
+    if (hasTopLevelAwait) return evaluateEsmAsync(filename, code);
     return evaluateEsm(filename, code);
   }
   function requireEsm(filename) {
@@ -15848,7 +15806,7 @@ function frameLocation(stack) {
   const file = m[1] === void 0 || m[0].includes("[eval]") ? "[eval]" : m[1];
   return { file, line: Number(m[2]), column: Number(m[3]) };
 }
-function snippetFor(ctx, loc, evalCode) {
+function snippetFor(ctx, loc, evalCode, fromPromise = false) {
   if (!loc) return null;
   let source;
   if (loc.file === "[eval]") source = evalCode;
@@ -15868,7 +15826,9 @@ function snippetFor(ctx, loc, evalCode) {
   let col2 = loc.column;
   const throwAt = text.search(/\bthrow\b/);
   const isAsyncLine = /\basync\b/.test(text);
-  if (loc.file === "[eval]" && throwAt === 0) {
+  if (fromPromise && loc.column >= 1) {
+    col2 = loc.column;
+  } else if (loc.file === "[eval]" && throwAt === 0) {
     col2 = 1;
   } else if (throwAt >= 0 && isAsyncLine && /\bthrow\s+new\b/.test(text)) {
     col2 = text.indexOf("new", throwAt) + 1;
@@ -15931,7 +15891,7 @@ function glueStackAndProps(stack, props) {
   if (!props) return frames;
   return `${frames} ${finalizeProps(props)}`;
 }
-function formatUncaughtError(err, { ctx, util: util2, version: version2, evalCode } = {}) {
+function formatUncaughtError(err, { ctx, util: util2, version: version2, evalCode, fromPromise } = {}) {
   const trailer = `
 Node.js v${version2}
 `;
@@ -16005,7 +15965,7 @@ ${trailer}` };
     }
   }
   const loc = frameLocation(rawStack);
-  const snip = snippetFor(ctx, loc, evalCode);
+  const snip = snippetFor(ctx, loc, evalCode, fromPromise);
   if (snip) head = `${snip.file}:${snip.lineNo}
 ${snip.text}
 ${snip.caret}
@@ -16102,7 +16062,7 @@ function collapseMatchingCauseFrames(body, err) {
 }
 function formatUnhandledRejection(reason, { ctx, util: util2, version: version2, evalCode } = {}) {
   if (reason instanceof Error) {
-    return formatUncaughtError(reason, { ctx, util: util2, version: version2, evalCode });
+    return formatUncaughtError(reason, { ctx, util: util2, version: version2, evalCode, fromPromise: true });
   }
   const trailer = `
 Node.js v${version2}
@@ -16114,13 +16074,84 @@ Node.js v${version2}
       new UnhandledPromiseRejection(reason);
       ^
 
-UnhandledPromiseRejection: ${msg} {
+UnhandledPromiseRejection: ${msg}
+    at throwUnhandledRejectionsMode (node:internal/process/promises:392:7)
+    at processPromiseRejections (node:internal/process/promises:475:17)
+    at process.processTicksAndRejections (node:internal/process/task_queues:106:32) {
   code: 'ERR_UNHANDLED_REJECTION'
 }
 `;
   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;
+    this.status = code;
+  }
+};
+function isExitError2(err) {
+  return err instanceof NodeExitError || err?.name === "NodeExitError" || err?.name === "JsExit";
+}
+function hardExitError(ctx, code) {
+  if (typeof ctx?.exit === "function") {
+    try {
+      ctx.exit(code);
+    } catch (err) {
+      if (err && typeof err === "object" && err.name === "JsExit") {
+        try {
+          Object.defineProperty(err, "name", { value: "NodeExitError", configurable: true, writable: true });
+          err.message = `Process exited with code ${code}`;
+          err.code = code;
+        } catch {
+        }
+        return err;
+      }
+    }
+  }
+  return new NodeExitError(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();
@@ -16156,6 +16187,7 @@ function createHandleTable() {
 // src/runtime/next-tick.mjs
 function createNextTick() {
   const queue = [];
+  let stopped = false;
   return {
     nextTick(fn, ...args) {
       if (typeof fn !== "function") {
@@ -16171,7 +16203,12 @@ function createNextTick() {
         err.code = "ERR_INVALID_ARG_TYPE";
         throw err;
       }
-      queue.push(() => fn(...args));
+      if (!stopped) queue.push(() => fn(...args));
+    },
+    /** process.exit(): drop what is queued and ignore new ticks. */
+    stop() {
+      stopped = true;
+      queue.length = 0;
     },
     /** Run queued ticks synchronously. */
     flushSync() {
@@ -16444,6 +16481,25 @@ function readProcessCreds(ctx) {
   }
   return { uid: 0, euid: 0, gid: 0, egid: 0, groups: [0] };
 }
+function resolveNodeExecPath(ctx) {
+  const fs = ctx?.sync?.fs;
+  const pathEnv = ctx?.env?.PATH ?? "/usr/local/bin:/usr/bin:/bin";
+  for (const dir of String(pathEnv).split(":")) {
+    if (!dir) continue;
+    const candidate = dir.endsWith("/") ? `${dir}node` : `${dir}/node`;
+    try {
+      if (fs?.exists?.(candidate)) {
+        try {
+          return typeof fs.realpath === "function" ? fs.realpath(candidate) : candidate;
+        } catch {
+          return candidate;
+        }
+      }
+    } catch {
+    }
+  }
+  return "/usr/bin/node";
+}
 var Process = class extends EventEmitter {
   constructor({ ctx, argv, nextTick, onExit, handles, Buffer: Buffer2 }) {
     super();
@@ -16464,7 +16520,7 @@ var Process = class extends EventEmitter {
     this.arch = "x64";
     this.pid = ctx.pid;
     this.ppid = void 0;
-    this.execPath = "/node_modules/@ai-ecoverse/slicc-jsh/dist/node.mjs";
+    this.execPath = resolveNodeExecPath(ctx);
     this.execArgv = [];
     this.nextTick = nextTick.nextTick.bind(nextTick);
     this._umask = 18;
@@ -16494,8 +16550,12 @@ var Process = class extends EventEmitter {
       tls: false,
       cached_builtins: true
     };
-    const writeStdout = (value) => ctx.sync.write(1, toBytes2(value));
-    const writeStderr = (value) => ctx.sync.write(2, toBytes2(value));
+    const writeStdout = (value) => {
+      if (!this._silenced) ctx.sync.write(1, toBytes2(value));
+    };
+    const writeStderr = (value) => {
+      if (!this._silenced) ctx.sync.write(2, toBytes2(value));
+    };
     this._writeStdout = writeStdout;
     this._writeStderr = writeStderr;
     this.stdout = writableStream(1, writeStdout, false);
@@ -16621,24 +16681,29 @@ var Process = class extends EventEmitter {
     }
     this._cwd = this._ctx.resolve(path);
   }
+  /**
+   * Node's process.exit: 'exit' listeners run, then the program ends. The
+   * kernel is told the status at once (see hardExitError); what still runs
+   * while the throw unwinds — a user `catch` or `finally` — is silenced:
+   * its output is dropped, a second exit() keeps the first status, and
+   * timers and ticks are stopped.
+   */
   exit(...args) {
-    if (args.length === 0) {
-      const code2 = numericExitCode(this._assignedExitCode);
-      this._recordExit(code2);
-      try {
-        this.emit("exit", code2);
-      } catch {
-      }
-      throw new NodeExitError(code2);
-    }
-    this._assignedExitCode = assignProcessExitCode(args[0]);
+    if (this._exitError) throw this._exitError;
+    if (args.length > 0) this._assignedExitCode = assignProcessExitCode(args[0]);
     const code = numericExitCode(this._assignedExitCode);
     this._recordExit(code);
     try {
       this.emit("exit", code);
     } catch {
     }
-    throw new NodeExitError(code);
+    this._silenced = true;
+    try {
+      this._onHardExit?.(code);
+    } catch {
+    }
+    this._exitError = hardExitError(this._ctx, code);
+    throw this._exitError;
   }
   _recordExit(code) {
     this._didExit = true;
@@ -16647,8 +16712,9 @@ var Process = class extends EventEmitter {
     this._onExit?.(code);
   }
 };
-function createProcess({ ctx, argv, nextTick, onExit, handles, Buffer: Buffer2 }) {
+function createProcess({ ctx, argv, nextTick, onExit, onHardExit, handles, Buffer: Buffer2 }) {
   const process2 = new Process({ ctx, argv, nextTick, onExit, handles, Buffer: Buffer2 });
+  process2._onHardExit = onHardExit;
   return {
     process: process2,
     writeStdout: process2._writeStdout,
@@ -16671,11 +16737,12 @@ function Timeout() {
 function Immediate() {
 }
 function createTimers(handles, { onCallbackError } = {}) {
-  const nativeSetTimeout = globalThis.setTimeout.bind(globalThis);
+  const nativeSetTimeout2 = globalThis.setTimeout.bind(globalThis);
   const nativeClearTimeout = globalThis.clearTimeout.bind(globalThis);
   const nativeSetInterval = globalThis.setInterval.bind(globalThis);
   const nativeClearInterval = globalThis.clearInterval.bind(globalThis);
   const byId = /* @__PURE__ */ new Map();
+  let stopped = false;
   const runMethod = (handle, method, args) => {
     try {
       handle[method](...args);
@@ -16709,6 +16776,9 @@ function createTimers(handles, { onCallbackError } = {}) {
     };
   };
   const makeTimeout = (fn, delay, args, repeating) => {
+    if (stopped) {
+      return repeating ? nativeSetInterval(fn, delay, ...args) : nativeSetTimeout2(fn, delay, ...args);
+    }
     const state = {
       refed: true,
       id: null,
@@ -16718,18 +16788,20 @@ function createTimers(handles, { onCallbackError } = {}) {
     handle._onTimeout = fn;
     attachRefApi(handle, state);
     const fire = () => {
+      if (stopped) return;
       if (!state.repeating) {
         byId.delete(state.id);
         handles.delete(state);
       }
       runMethod(handle, "_onTimeout", args);
     };
-    state.id = repeating ? nativeSetInterval(fire, delay ?? 0) : nativeSetTimeout(fire, delay ?? 0);
+    state.id = repeating ? nativeSetInterval(fire, delay ?? 0) : nativeSetTimeout2(fire, delay ?? 0);
     byId.set(state.id, state);
     handles.add(state);
     return handle;
   };
   const makeImmediate = (fn, args) => {
+    if (stopped) return nativeSetTimeout2(fn, 0, ...args);
     const state = {
       refed: true,
       id: null,
@@ -16739,11 +16811,12 @@ function createTimers(handles, { onCallbackError } = {}) {
     handle._onImmediate = fn;
     attachRefApi(handle, state);
     const fire = () => {
+      if (stopped) return;
       byId.delete(state.id);
       handles.delete(state);
       runMethod(handle, "_onImmediate", args);
     };
-    state.id = nativeSetTimeout(fire, 0);
+    state.id = nativeSetTimeout2(fire, 0);
     byId.set(state.id, state);
     handles.add(state);
     return handle;
@@ -16759,7 +16832,7 @@ function createTimers(handles, { onCallbackError } = {}) {
   };
   return {
     setTimeout: (fn, delay, ...args) => {
-      if (typeof fn !== "function") return nativeSetTimeout(fn, delay, ...args);
+      if (typeof fn !== "function") return nativeSetTimeout2(fn, delay, ...args);
       return makeTimeout(fn, delay, args, false);
     },
     clearTimeout: (handle) => clear(handle, nativeClearTimeout),
@@ -16769,7 +16842,7 @@ function createTimers(handles, { onCallbackError } = {}) {
     },
     clearInterval: (handle) => clear(handle, nativeClearInterval),
     setImmediate: (fn, ...args) => {
-      if (typeof fn !== "function") return nativeSetTimeout(fn, 0, ...args);
+      if (typeof fn !== "function") return nativeSetTimeout2(fn, 0, ...args);
       return makeImmediate(fn, args);
     },
     clearImmediate: (handle) => clear(handle, nativeClearTimeout),
@@ -16781,12 +16854,60 @@ function createTimers(handles, { onCallbackError } = {}) {
       }
       byId.clear();
       handles.notify();
+    },
+    /** The program is ending: clear its timers; later ones bypass the table. */
+    stop() {
+      stopped = true;
+      this.clearPending();
     }
   };
 }
 
 // src/runtime/web/fetch.mjs
-function createFetch(ctx) {
+var BODY_METHODS = ["arrayBuffer", "blob", "bytes", "formData", "json", "text"];
+function trackBody(response, track) {
+  for (const name of BODY_METHODS) {
+    const method = response[name];
+    if (typeof method !== "function") continue;
+    Object.defineProperty(response, name, {
+      value: function tracked(...args) {
+        return track(method.apply(response, args));
+      },
+      configurable: true,
+      writable: true
+    });
+  }
+  const bodyDesc = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(response), "body");
+  if (!bodyDesc?.get) return response;
+  let wrapped;
+  Object.defineProperty(response, "body", {
+    configurable: true,
+    get() {
+      if (wrapped !== void 0) return wrapped;
+      const original = bodyDesc.get.call(response);
+      if (original == null || typeof ReadableStream !== "function") {
+        wrapped = original;
+        return wrapped;
+      }
+      let reader;
+      wrapped = new ReadableStream({
+        async pull(controller) {
+          reader ??= original.getReader();
+          const { value, done } = await track(reader.read());
+          if (done) controller.close();
+          else controller.enqueue(value);
+        },
+        cancel(reason) {
+          return (reader ?? original).cancel(reason);
+        }
+      });
+      return wrapped;
+    }
+  });
+  return response;
+}
+function createFetch(ctx, { handles } = {}) {
+  const track = (p) => handles ? trackPromise(handles, p) : p;
   async function fetch(input, init) {
     if (typeof ctx.fetch !== "function") {
       const err = new TypeError("fetch failed");
@@ -16795,7 +16916,13 @@ function createFetch(ctx) {
       });
       throw err;
     }
-    return ctx.fetch(input, init);
+    const response = await track(ctx.fetch(input, init));
+    if (!handles || response == null || typeof response !== "object") return response;
+    try {
+      return trackBody(response, track);
+    } catch {
+      return response;
+    }
   }
   return fetch;
 }
@@ -17110,6 +17237,43 @@ function installJshGlobals(bindings) {
     }
   };
 }
+function trackPlatformAsync(handles) {
+  const undo = [];
+  const wrap = (target, names) => {
+    if (!target) return;
+    for (const name of names) {
+      const original = target[name];
+      if (typeof original !== "function") continue;
+      try {
+        target[name] = function tracked(...args) {
+          return trackPromise(handles, original.apply(this, args));
+        };
+        undo.push(() => {
+          target[name] = original;
+        });
+      } catch {
+      }
+    }
+  };
+  wrap(globalThis.SubtleCrypto?.prototype, [
+    "decrypt",
+    "deriveBits",
+    "deriveKey",
+    "digest",
+    "encrypt",
+    "exportKey",
+    "generateKey",
+    "importKey",
+    "sign",
+    "unwrapKey",
+    "verify",
+    "wrapKey"
+  ]);
+  wrap(globalThis.WebAssembly, ["compile", "compileStreaming", "instantiate", "instantiateStreaming"]);
+  return () => {
+    for (const fn of undo.reverse()) fn();
+  };
+}
 async function runNode(ctx, options = {}) {
   installStackPrepare();
   const handles = createHandleTable();
@@ -17169,6 +17333,12 @@ slicc-jsh ${NODE_SHIM_VERSION} (Node-compatible, abi: js)
     Buffer: Buffer2,
     onExit: (code) => {
       exitStatus = code;
+    },
+    // process.exit(): nothing the unwinding code schedules may run.
+    onHardExit: () => {
+      timers.stop();
+      nextTick.stop();
+      handles.notify();
     }
   });
   process2.execArgv = parsed.execArgv ? [...parsed.execArgv] : [];
@@ -17177,12 +17347,13 @@ slicc-jsh ${NODE_SHIM_VERSION} (Node-compatible, abi: js)
     lastEvalCode = parsed.code;
   }
   const console2 = createConsole(writeStdout, writeStderr, util2);
-  const fetch = createFetch(ctx);
+  const fetch = createFetch(ctx, { handles });
+  const restorePlatform = trackPlatformAsync(handles);
   const WebSocket = createWebSocket(ctx, { handles, trackPromise });
   const timers = createTimers(handles, {
     onCallbackError: (err) => {
-      if (err instanceof NodeExitError) {
-        exitStatus = err.code;
+      if (isExitError2(err) || getDidExit()) {
+        exitStatus = getDidExit() ? getExitCode() : err.code;
         timers.clearPending();
         try {
           handles.notify();
@@ -17230,16 +17401,16 @@ slicc-jsh ${NODE_SHIM_VERSION} (Node-compatible, abi: js)
     } catch {
     }
     exitStatus = 1;
-    timers.clearPending();
+    timers.stop();
     try {
       ctx.exit?.(1);
     } catch {
     }
   };
-  const isExit = (err) => err instanceof NodeExitError || err?.name === "NodeExitError" || getDidExit();
+  const isExit = (err) => isExitError2(err) || getDidExit();
   const rejectionHandler = (reason, promise) => {
     if (isExit(reason)) {
-      exitStatus = reason instanceof NodeExitError || reason?.name === "NodeExitError" ? Number(reason.code) & 255 : getExitCode();
+      exitStatus = getDidExit() ? getExitCode() : Number(reason.code) & 255;
       timers.clearPending();
       try {
         handles.notify();
@@ -17258,16 +17429,16 @@ slicc-jsh ${NODE_SHIM_VERSION} (Node-compatible, abi: js)
       evalCode: lastEvalCode
     });
     writeStderr(body);
+    exitStatus = 1;
+    timers.stop();
     try {
       ctx.exit?.(1);
     } catch {
     }
-    exitStatus = 1;
-    timers.clearPending();
   };
   const exceptionHandler = (err) => {
     if (isExit(err)) {
-      exitStatus = err instanceof NodeExitError || err?.name === "NodeExitError" ? Number(err.code) & 255 : getExitCode();
+      exitStatus = getDidExit() ? getExitCode() : Number(err.code) & 255;
       timers.clearPending();
       try {
         handles.notify();
@@ -17338,8 +17509,27 @@ slicc-jsh ${NODE_SHIM_VERSION} (Node-compatible, abi: js)
   });
   cjs.setRequireEsmHook((filename) => esm.requireEsm(filename));
   cjs.setImportModuleHook((specifier, parent) => esm.importModule(specifier, parent));
+  let entry = null;
+  const setEntry = (promise, kind) => {
+    const current2 = { kind, pending: true, promise };
+    entry = current2;
+    Promise.resolve(promise).then(
+      () => {
+        current2.pending = false;
+        handles.notify();
+      },
+      (err) => {
+        current2.pending = false;
+        if (kind === "jsh") rejectionHandler(err, promise);
+        else exceptionHandler(err);
+        handles.notify();
+      }
+    );
+  };
   try {
     const rt = {
+      setEntry,
+      track: (promise) => trackPromise(handles, promise),
       process: process2,
       console: console2,
       Buffer: Buffer2,
@@ -17359,7 +17549,7 @@ slicc-jsh ${NODE_SHIM_VERSION} (Node-compatible, abi: js)
         }
         nextTick.flushSync();
       } catch (err) {
-        if (err instanceof NodeExitError) throw err;
+        if (isExitError2(err)) throw err;
         if (process2.listenerCount("uncaughtException") > 0) {
           process2.emit(
             "uncaughtException",
@@ -17407,7 +17597,7 @@ slicc-jsh ${NODE_SHIM_VERSION} (Node-compatible, abi: js)
         cjs.runMain("[stdin]", source, { setMain: false });
         nextTick.flushSync();
       } catch (err) {
-        if (err instanceof NodeExitError) throw err;
+        if (isExitError2(err)) throw err;
         if (process2.listenerCount("uncaughtException") > 0) {
           process2.emit(
             "uncaughtException",
@@ -17429,10 +17619,7 @@ slicc-jsh ${NODE_SHIM_VERSION} (Node-compatible, abi: js)
 )` : parsed.code,
             "[eval]"
           );
-          if (result != null && typeof result.then === "function") {
-            trackPromise(handles, result);
-            await result;
-          }
+          if (result != null && typeof result.then === "function") setEntry(result, "esm");
           nextTick.flushSync();
         } else {
           const evalParent = `${process2.cwd()}/[eval]`;
@@ -17466,7 +17653,7 @@ slicc-jsh ${NODE_SHIM_VERSION} (Node-compatible, abi: js)
           }
         }
       } catch (err) {
-        if (err instanceof NodeExitError) throw err;
+        if (isExitError2(err)) throw err;
         if (process2.listenerCount("uncaughtException") > 0) {
           process2.emit(
             "uncaughtException",
@@ -17494,16 +17681,13 @@ slicc-jsh ${NODE_SHIM_VERSION} (Node-compatible, abi: js)
         const useEsm = esm.isEsmFilename(filePath, source);
         if (useEsm) {
           const result = esm.runMain(filePath, source);
-          if (result != null && typeof result.then === "function") {
-            trackPromise(handles, result);
-            await result;
-          }
+          if (result != null && typeof result.then === "function") setEntry(result, "esm");
         } else {
           cjs.runMain(filePath, source);
         }
         nextTick.flushSync();
       } catch (err) {
-        if (err instanceof NodeExitError) throw err;
+        if (isExitError2(err)) throw err;
         if (process2.listenerCount("uncaughtException") > 0) {
           process2.emit(
             "uncaughtException",
@@ -17524,8 +17708,17 @@ slicc-jsh ${NODE_SHIM_VERSION} (Node-compatible, abi: js)
       onBeforeExit: () => {
         emitBeforeExit();
       },
-      shouldStop: () => getDidExit() || exitStatus !== void 0
+      shouldStop: () => getDidExit() || exitStatus !== void 0,
+      weakPending: () => entry?.pending === true
     });
+    if (entry?.pending && entry.kind === "esm" && exitStatus === void 0 && !getDidExit()) {
+      const where = parsed.mode === "file" ? `file://${process2.argv[1]}` : "[eval1]";
+      writeStderr(`Warning: Detected unsettled top-level await at ${where}
+
+
+`);
+      exitStatus = 13;
+    }
     for (let i2 = 0; i2 < 3; i2++) {
       if (exitStatus !== void 0 || getDidExit()) break;
       await new Promise((resolve2) => {
@@ -17550,9 +17743,9 @@ slicc-jsh ${NODE_SHIM_VERSION} (Node-compatible, abi: js)
     }
     return code;
   } catch (err) {
-    if (err instanceof NodeExitError) {
+    if (isExitError2(err)) {
       timers.clearPending();
-      return err.code;
+      return getDidExit() ? getExitCode() : err.code;
     }
     try {
       printUncaught(err);
@@ -17563,7 +17756,7 @@ slicc-jsh ${NODE_SHIM_VERSION} (Node-compatible, abi: js)
     return 1;
   } finally {
     timers.clearPending();
-    for (const remove of removeCtxHooks) {
+    for (const remove of getDidExit() ? [] : removeCtxHooks) {
       try {
         remove?.();
       } catch {
@@ -17571,6 +17764,7 @@ slicc-jsh ${NODE_SHIM_VERSION} (Node-compatible, abi: js)
     }
     try {
       restoreGlobals();
+      restorePlatform();
       removeJshHandoff();
     } catch {
     }