@ai-ecoverse/slicc-kernel 1.164.5 → 1.165.0

package/dist/node-process-worker.js

@@ -1,9 +1,9 @@
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res, err) => function __init() {
+var __esm = (fn2, res, err) => function __init() {
   if (err) throw err[0];
   try {
-    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+    return fn2 && (res = (0, fn2[__getOwnPropNames(fn2)[0]])(fn2 = 0)), res;
   } catch (e) {
     throw err = [e], e;
   }
@@ -78,6 +78,23 @@ var init_captured_globals = __esm({
   }
 });
 
+// src/process/raw-stack.ts
+function setRawStack(read2) {
+  reader = read2;
+}
+function rawStack(error) {
+  const stack = reader(error);
+  return typeof stack === "string" ? stack : void 0;
+}
+var reader;
+var init_raw_stack = __esm({
+  "src/process/raw-stack.ts"() {
+    "use strict";
+    init_captured_globals();
+    reader = (error) => error.stack;
+  }
+});
+
 // src/process/js/lockdown.ts
 function chain(target) {
   const out = [];
@@ -3412,7 +3429,7 @@ var init_wasi_cred = __esm({
     };
     KNOWN = 65536;
     LOCKED = 131072;
-    UNGATED = { quiet: (fn) => fn(), deliver: () => {
+    UNGATED = { quiet: (fn2) => fn2(), deliver: () => {
     } };
     UmaskCache = class {
       mask;
@@ -5527,21 +5544,21 @@ function kernelFiletype(kind) {
 }
 function direntRecord(next2, ino, name2, filetype) {
   const nameBytes = new capturedTextEncoder().encode(name2);
-  const record = new capturedUint8Array(SIZE.DIRENT + nameBytes.length);
-  const v = new capturedDataView(record.buffer);
+  const record2 = new capturedUint8Array(SIZE.DIRENT + nameBytes.length);
+  const v = new capturedDataView(record2.buffer);
   v.setBigUint64(0, capturedBigInt(next2), true);
   v.setBigUint64(8, ino, true);
   v.setUint32(16, nameBytes.length, true);
   v.setUint8(20, filetype);
-  record.set(nameBytes, SIZE.DIRENT);
-  return record;
+  record2.set(nameBytes, SIZE.DIRENT);
+  return record2;
 }
 function wrap(table) {
   const out = {};
-  for (const [name2, fn] of capturedObject.entries(table)) {
+  for (const [name2, fn2] of capturedObject.entries(table)) {
     out[name2] = (...args) => {
       try {
-        return fn(...args) ?? E.SUCCESS;
+        return fn2(...args) ?? E.SUCCESS;
       } catch (e) {
         if (e instanceof WasiExit) throw e;
         if (e instanceof WasiError) return wasiErrnoOf(e.code);
@@ -5661,7 +5678,7 @@ var init_wasi_host = __esm({
             mask === void 0 ? { op: "proc-umask" } : { op: "proc-umask", mask }
           ),
           o.credGen ?? o.shared,
-          { quiet: (fn) => this.quietly(fn), deliver: () => this.deliverDue() }
+          { quiet: (fn2) => this.quietly(fn2), deliver: () => this.deliverDue() }
         );
         if (o.shared) this.fds.share(o.shared, true);
         else if (o.forked) this.fds.restore(o.forked.fds, o.forked.cloexec);
@@ -6768,14 +6785,14 @@ var init_wasi_host = __esm({
           const full = name2 === "." ? dir.path : name2 === ".." ? normalize(`${dir.path}/..`) : resolveUnder(dir.path, name2);
           if (!stats.has(name2)) stats.set(name2, this.lstatOrNull(full));
           const st = stats.get(name2) ?? null;
-          const record = direntRecord(
+          const record2 = direntRecord(
             i + 1,
             st?.ino !== void 0 ? capturedBigInt(st.ino) : pathInode(full),
             name2,
             filetypeOf(st)
           );
-          const n = capturedMath.min(record.length, len - at);
-          this.mem.bytes(buf + at, n).set(record.subarray(0, n));
+          const n = capturedMath.min(record2.length, len - at);
+          this.mem.bytes(buf + at, n).set(record2.subarray(0, n));
           at += n;
         }
         this.mem.view().setUint32(usedPtr, at, true);
@@ -7385,7 +7402,7 @@ var init_version = __esm({
   "src/version.ts"() {
     "use strict";
     init_captured_globals();
-    KERNEL_VERSION = true ? "1.164.5" : "0.0.0-dev";
+    KERNEL_VERSION = true ? "1.165.0" : "0.0.0-dev";
     OS_RELEASE = "6.0.0-slicc";
   }
 });
@@ -7860,14 +7877,14 @@ function bytesOf(chunk) {
 async function bodyOf(request, cap, signal) {
   signal.throwIfAborted();
   if (!request.body || request.method === "GET" || request.method === "HEAD") return void 0;
-  const reader = request.body.getReader();
-  const stop = () => void reader.cancel(signal.reason).catch(() => void 0);
+  const reader2 = request.body.getReader();
+  const stop = () => void reader2.cancel(signal.reason).catch(() => void 0);
   signal.addEventListener("abort", stop, { once: true });
   const parts = [];
   let length = 0;
   try {
     for (; ; ) {
-      const next2 = await reader.read().catch((err) => {
+      const next2 = await reader2.read().catch((err) => {
         throw signal.aborted ? signal.reason : failed(err);
       });
       signal.throwIfAborted();
@@ -7875,7 +7892,7 @@ async function bodyOf(request, cap, signal) {
       const chunk = bytesOf(next2.value);
       length += chunk.length;
       if (length > cap) {
-        reader.cancel().catch(() => void 0);
+        reader2.cancel().catch(() => void 0);
         return OVER;
       }
       parts.push(chunk);
@@ -7897,24 +7914,24 @@ function streams(known, request, init, url) {
   return request.method !== "GET" && request.method !== "HEAD" && !local2(url);
 }
 async function pump(kernel, handle, stream, signal) {
-  const reader = stream.getReader();
-  const stop = () => void reader.cancel(signal.reason).catch(() => void 0);
+  const reader2 = stream.getReader();
+  const stop = () => void reader2.cancel(signal.reason).catch(() => void 0);
   signal.addEventListener("abort", stop, { once: true });
   try {
-    await pumpFrom(kernel, handle, reader, signal);
+    await pumpFrom(kernel, handle, reader2, signal);
   } finally {
     signal.removeEventListener("abort", stop);
   }
 }
-async function pumpFrom(kernel, handle, reader, signal) {
+async function pumpFrom(kernel, handle, reader2, signal) {
   for (; ; ) {
     let bytes;
     try {
-      const next2 = await reader.read();
+      const next2 = await reader2.read();
       if (next2.done) break;
       bytes = bytesOf(next2.value);
     } catch (err) {
-      await reader.cancel(err).catch(() => void 0);
+      await reader2.cancel(err).catch(() => void 0);
       await kernel.raw({ op: "net-close", handle });
       return;
     }
@@ -7924,7 +7941,7 @@ async function pumpFrom(kernel, handle, reader, signal) {
       () => false
     );
     if (!taken) {
-      await reader.cancel().catch(() => void 0);
+      await reader2.cancel().catch(() => void 0);
       return;
     }
   }
@@ -9138,7 +9155,7 @@ function createHelpers(Fs, ops) {
   const dirty = new capturedSet();
   const handled = new capturedSet();
   const linked = linkedStates(bridgeOf);
-  const renames = renameFollower(Fs, bridgeOf, (fn) => call3(fn));
+  const renames = renameFollower(Fs, bridgeOf, (fn2) => call3(fn2));
   function markDirty(node) {
     node.live.dirty = true;
     dirty.add(node);
@@ -9158,16 +9175,16 @@ function createHelpers(Fs, ops) {
       }
     }
   }
-  function call3(fn) {
+  function call3(fn2) {
     try {
-      return fn();
+      return fn2();
     } catch (err) {
       throw toErrno(Fs, err);
     }
   }
-  function metadataCall(fn) {
+  function metadataCall(fn2) {
     try {
-      call3(fn);
+      call3(fn2);
     } catch (err) {
       if (err.errno !== wasiErrno("ENOSYS")) throw err;
     }
@@ -11990,9 +12007,9 @@ function procfsBridge(fs, tree) {
     [NOT_FOLLOWING, false]
   ]) {
     for (const name2 of names) {
-      const fn = fs[name2];
-      if (!fn) continue;
-      over[name2] = (p, ...rest2) => readOnly2([[p, follow3]], () => fn.call(fs, p, ...rest2));
+      const fn2 = fs[name2];
+      if (!fn2) continue;
+      over[name2] = (p, ...rest2) => readOnly2([[p, follow3]], () => fn2.call(fs, p, ...rest2));
     }
   }
   const { chown } = fs;
@@ -14439,10 +14456,10 @@ var init_process_signals = __esm({
         };
         this.raw.call(req, capturedNumber.POSITIVE_INFINITY, "sig-mask");
       }
-      quiet(fn) {
+      quiet(fn2) {
         this.quieted++;
         try {
-          return fn();
+          return fn2();
         } finally {
           this.quieted--;
         }
@@ -15519,7 +15536,7 @@ function createJsWasi(deps, o = {}) {
     view().setUint32(out, g, true);
   };
   const imports = {};
-  for (const [name2, fn] of capturedObject.entries(table)) {
+  for (const [name2, fn2] of capturedObject.entries(table)) {
     if (SPECIAL.has(name2)) continue;
     const fdArgs = fdArgsOf(name2);
     imports[name2] = ((...raw) => {
@@ -15532,7 +15549,7 @@ function createJsWasi(deps, o = {}) {
       if (!confined(name2, raw)) return E.NOTCAPABLE;
       const out = RESULTS[name2];
       if (out !== void 0 && (raw[out] >>> 0) + 4 > host.mem.size()) return E.FAULT;
-      const errno2 = fn(...args);
+      const errno2 = fn2(...args);
       if (errno2 !== E.SUCCESS) return errno2;
       if (out !== void 0) opens(raw[out] >>> 0, roots.get(raw[0]));
       return errno2;
@@ -15585,13 +15602,13 @@ function createJsWasi(deps, o = {}) {
   const run = (instance, entry) => {
     const memory = instance.exports.memory;
     if (memory instanceof capturedWebAssembly.Memory) host.mem.bind(memory);
-    const fn = instance.exports[entry];
-    if (typeof fn !== "function") {
+    const fn2 = instance.exports[entry];
+    if (typeof fn2 !== "function") {
       if (entry === "_initialize") return 0;
       throw new JsCallError("EINVAL", `wasi: the instance exports no ${entry}`);
     }
     try {
-      fn();
+      fn2();
       return 0;
     } catch (err) {
       if (err instanceof JsWasiExit && o.returnOnExit !== false) return err.code;
@@ -16208,7 +16225,9 @@ function realmOps(o) {
   return {
     runScript: scriptRunner(o.runScript),
     promiseState: (promise) => o.promiseState?.(promise),
-    ...hook ? { setStackFormatter: (fn) => hook(fn) } : {},
+    ...hook ? {
+      setStackFormatter: (fn2, options) => hook(fn2, options)
+    } : {},
     ...source ? { errorSource: (error) => source(error) } : {}
   };
 }
@@ -17180,8 +17199,8 @@ var init_wasi_signals = __esm({
         if (defaultAction(sig) !== "terminate") this.uncaught &= ~sigbit(sig);
       }
       handler() {
-        const fn = this.callback ? this.exports?.[this.callback] : void 0;
-        return typeof fn === "function" ? fn : void 0;
+        const fn2 = this.callback ? this.exports?.[this.callback] : void 0;
+        return typeof fn2 === "function" ? fn2 : void 0;
       }
     };
   }
@@ -17201,16 +17220,16 @@ var init_wasi_stats = __esm({
         return capturedObject.fromEntries(
           capturedObject.entries(table).map(([name2, value2]) => {
             if (typeof value2 !== "function") return [name2, value2];
-            const fn = value2;
+            const fn2 = value2;
             const key = `${tag}.${name2}`;
-            return [name2, (...args) => this.time(key, () => fn.apply(table, args))];
+            return [name2, (...args) => this.time(key, () => fn2.apply(table, args))];
           })
         );
       }
-      time(key, fn) {
+      time(key, fn2) {
         const t = capturedperformance.now();
         try {
-          return fn();
+          return fn2();
         } finally {
           this.count(key, capturedperformance.now() - t);
         }
@@ -17435,9 +17454,9 @@ function callDynamic(ctx, ...operands) {
   const [id, values, valuesLen, results, resultsLen, strict] = operands.map((n) => n >>> 0);
   const table = ctx.table();
   if (!table) throw new WasiError("ENOTSUP");
-  const fn = id < table.length ? table.get(id) : null;
-  const sig = fn ? ctx.types.of(fn) : void 0;
-  if (!fn || !sig) throw new WasiError("EINVAL");
+  const fn2 = id < table.length ? table.get(id) : null;
+  const sig = fn2 ? ctx.types.of(fn2) : void 0;
+  if (!fn2 || !sig) throw new WasiError("EINVAL");
   const params = scalars(sig.params);
   const outs = scalars(sig.results);
   const size = (types3) => types3.reduce((n, type) => n + SIZE2[type], 0);
@@ -17455,7 +17474,7 @@ function callDynamic(ctx, ...operands) {
     at += SIZE2[type];
     return v;
   });
-  const returned = fn(...args);
+  const returned = fn2(...args);
   const got = outs.length === 1 ? [returned] : returned ?? [];
   const after = ctx.mem.view();
   const stop = results + resultsLen;
@@ -17837,30 +17856,30 @@ var init_wasm_functypes = __esm({
       add(info, instance, table, tableBase) {
         const sig = (func) => info.sigs[info.funcs[func] ?? -1];
         for (const [name2, func] of capturedObject.entries(info.exports)) {
-          const fn = instance.exports[name2];
+          const fn2 = instance.exports[name2];
           const type = sig(func);
-          if (typeof fn === "function" && type) this.known.set(fn, type);
+          if (typeof fn2 === "function" && type) this.known.set(fn2, type);
         }
         if (!table) return;
         for (const seg of info.elems) {
           const start2 = seg.offset + (seg.tableBase ? tableBase : 0);
           seg.funcs.forEach((func, i) => {
             const type = sig(func);
-            const fn = start2 + i < table.length ? table.get(start2 + i) : null;
-            if (fn && type) this.known.set(fn, type);
+            const fn2 = start2 + i < table.length ? table.get(start2 + i) : null;
+            if (fn2 && type) this.known.set(fn2, type);
           });
         }
       }
-      set(fn, sig) {
-        this.known.set(fn, sig);
+      set(fn2, sig) {
+        this.known.set(fn2, sig);
       }
-      of(fn) {
-        const known = this.known.get(fn);
+      of(fn2) {
+        const known = this.known.get(fn2);
         if (known || this.pending.length === 0) return known;
         const pending = this.pending;
         this.pending = [];
         for (const run of pending) run();
-        return this.known.get(fn);
+        return this.known.get(fn2);
       }
     };
   }
@@ -17881,8 +17900,8 @@ function growTable(table, length) {
   if (table.length < length) table.grow(length - table.length);
 }
 function call2(instance, name2) {
-  const fn = instance.exports[name2];
-  if (typeof fn === "function") fn();
+  const fn2 = instance.exports[name2];
+  if (typeof fn2 === "function") fn2();
 }
 var TABLE_BASE2, PAGE2, STACK_SIZE, LIBRARY_DIRS, DlError, WasixLinker;
 var init_wasix_linker = __esm({
@@ -18033,23 +18052,23 @@ var init_wasix_linker = __esm({
         this.table.set(index3, null);
       }
       live = new capturedSet();
-      prepareClosure(record) {
-        if (!this.live.has(record.index)) throw new DlError(`closure ${record.index}: not allocated`);
-        const full = { kind: "closure-prepare", ...record };
+      prepareClosure(record2) {
+        if (!this.live.has(record2.index)) throw new DlError(`closure ${record2.index}: not allocated`);
+        const full = { kind: "closure-prepare", ...record2 };
         this.install(full);
         this.publisher?.(full);
       }
-      install(record) {
-        growTable(this.table, record.index + 1);
-        const { fn, sig } = this.trampolines.make(record.params, record.results, {
+      install(record2) {
+        growTable(this.table, record2.index + 1);
+        const { fn: fn2, sig } = this.trampolines.make(record2.params, record2.results, {
           memory: this.memory,
           table: this.table,
           stackPointer: this.stackPointer,
-          backing: record.backing,
-          userData: record.userData
+          backing: record2.backing,
+          userData: record2.userData
         });
-        this.table.set(record.index, fn);
-        this.types.set(fn, sig);
+        this.table.set(record2.index, fn2);
+        this.types.set(fn2, sig);
       }
       reserveLoad(size) {
         return this.indices?.load(this.table.length, size) ?? {
@@ -18079,33 +18098,33 @@ var init_wasix_linker = __esm({
         );
         return true;
       }
-      replay(record) {
-        if (record.kind === "closure") {
-          growTable(this.table, record.index + 1);
-          this.live.add(record.index);
+      replay(record2) {
+        if (record2.kind === "closure") {
+          growTable(this.table, record2.index + 1);
+          this.live.add(record2.index);
           return;
         }
-        if (record.kind === "closure-free") {
-          this.live.delete(record.index);
-          if (record.index < this.table.length) this.table.set(record.index, null);
+        if (record2.kind === "closure-free") {
+          this.live.delete(record2.index);
+          if (record2.index < this.table.length) this.table.set(record2.index, null);
           return;
         }
-        if (record.kind === "closure-prepare") {
-          this.install(record);
+        if (record2.kind === "closure-prepare") {
+          this.install(record2);
           return;
         }
-        if (record.kind === "load") {
-          if (this.modules.has(record.handle)) return;
-          const linked = this.instantiate(record.path, this.moduleAt(record.path), record, false);
-          linked.needed.push(...record.needed ?? []);
-          this.nextHandle = capturedMath.max(this.nextHandle, record.handle + 1);
+        if (record2.kind === "load") {
+          if (this.modules.has(record2.handle)) return;
+          const linked = this.instantiate(record2.path, this.moduleAt(record2.path), record2, false);
+          linked.needed.push(...record2.needed ?? []);
+          this.nextHandle = capturedMath.max(this.nextHandle, record2.handle + 1);
           return;
         }
-        const value2 = record.handle === 0 ? this.main?.exports[record.name] : this.module(record.handle).instance.exports[record.name];
-        if (typeof value2 !== "function") throw new DlError(`${record.name}: not a function`);
-        growTable(this.table, record.index + 1);
-        this.table.set(record.index, value2);
-        this.slots.set(value2, record.index);
+        const value2 = record2.handle === 0 ? this.main?.exports[record2.name] : this.module(record2.handle).instance.exports[record2.name];
+        if (typeof value2 !== "function") throw new DlError(`${record2.name}: not a function`);
+        growTable(this.table, record2.index + 1);
+        this.table.set(record2.index, value2);
+        this.slots.set(value2, record2.index);
       }
       moduleAt(path) {
         const cached2 = this.cache?.[path];
@@ -18148,7 +18167,7 @@ var init_wasix_linker = __esm({
         );
         const memoryBase = this.allocate(info.memorySize, 2 ** info.memoryAlign);
         const { base: tableBase, handle } = this.reserveLoad(info.tableSize);
-        const record = {
+        const record2 = {
           kind: "load",
           handle,
           path,
@@ -18156,9 +18175,9 @@ var init_wasix_linker = __esm({
           tableBase,
           ...needed.length > 0 ? { needed } : {}
         };
-        const linked = this.instantiate(path, module, record, true);
+        const linked = this.instantiate(path, module, record2, true);
         linked.needed.push(...needed);
-        this.publisher?.(record);
+        this.publisher?.(record2);
         return linked;
       }
       instantiate(path, module, at, init) {
@@ -18273,19 +18292,19 @@ var init_wasix_linker = __esm({
       indexed = 0;
       indexTable() {
         for (let i = this.indexed; i < this.table.length; i++) {
-          const fn = this.table.get(i);
-          if (fn && !this.slots.has(fn)) this.slots.set(fn, i);
+          const fn2 = this.table.get(i);
+          if (fn2 && !this.slots.has(fn2)) this.slots.set(fn2, i);
         }
         this.indexed = this.table.length;
       }
-      slot(fn, handle, name2) {
+      slot(fn2, handle, name2) {
         this.indexTable();
-        const known = this.slots.get(fn);
+        const known = this.slots.get(fn2);
         if (known !== void 0) return known;
         const index3 = this.reserve(1);
         growTable(this.table, index3 + 1);
-        this.table.set(index3, fn);
-        this.slots.set(fn, index3);
+        this.table.set(index3, fn2);
+        this.slots.set(fn2, index3);
         this.publisher?.({ kind: "slot", index: index3, handle, name: name2 });
         return index3;
       }
@@ -18876,7 +18895,7 @@ __export(wasi_runtime_exports, {
 function wireSignals(host, gate) {
   host.interrupted = () => gate.interrupt();
   host.raisedOnEntry = () => gate.raisedOnEntry();
-  host.quietly = (fn) => gate.quiet(fn);
+  host.quietly = (fn2) => gate.quiet(fn2);
   host.deliverDue = () => void gate.interrupt();
   host.fds.restartable = () => gate.restartable();
 }
@@ -18897,7 +18916,7 @@ function delivering(ns, table, host, driver, before) {
       out[name2] = value2;
       continue;
     }
-    const fn = value2;
+    const fn2 = value2;
     out[name2] = (...args) => {
       host.entered = false;
       if (driver.idle) {
@@ -18905,7 +18924,7 @@ function delivering(ns, table, host, driver, before) {
         host.entered = host.interrupted?.() === true;
         host.enteredSignals = host.entered ? host.raisedOnEntry?.() ?? -1 : 0;
       }
-      return fn(...args);
+      return fn2(...args);
     };
   }
   return out;
@@ -19344,7 +19363,7 @@ async function runWasiProcess(init, port3) {
 function trapMessage(e, env, where = "", name2) {
   const head = `wasm trap${where}: ${e.message}`;
   if (env.SLICC_WASM_BACKTRACE !== "1") return head;
-  const lines = (e.stack ?? "").split("\n");
+  const lines = (rawStack(e) ?? "").split("\n");
   const main = name2 && mainModule(lines);
   const frames = lines.filter((line) => /^\s+at .*wasm:\/\/wasm\//.test(line)).slice(0, BACKTRACE_FRAMES).map((line) => name2 && main ? nameFrame(line, main, name2) : line);
   return frames.length ? `${head}
@@ -19468,6 +19487,7 @@ var init_wasi_runtime = __esm({
     init_kernel_streams();
     init_process_runtime();
     init_process_signals();
+    init_raw_stack();
     init_dylink();
     init_wasi_files();
     init_wasi_host();
@@ -19533,7 +19553,7 @@ var init_wasi_runtime = __esm({
         this.call = call3;
         this.ids = threads?.ids;
         this.owner = threads?.tid ?? 0;
-        linker.publisher = (record) => this.publish(record);
+        linker.publisher = (record2) => this.publish(record2);
         linker.indices = {
           reserve: (floor, size) => this.call({ op: "dl-reserve", floor, size }),
           load: (floor, size) => this.call({ op: "dl-load-reserve", floor, size }),
@@ -19562,8 +19582,8 @@ var init_wasi_runtime = __esm({
       bump() {
         if (this.ids) capturedAtomics.add(this.ids, DL_GEN, 1);
       }
-      publish(record) {
-        const since = this.call({ op: "dl-log", append: record, from: this.count });
+      publish(record2) {
+        const since = this.call({ op: "dl-log", append: record2, from: this.count });
         for (const r of since.slice(0, -1)) this.linker.replay(r);
         this.count += since.length;
         this.bump();
@@ -19588,11 +19608,11 @@ var init_wasi_runtime = __esm({
         const ids = this.ids;
         if (!ids) return { preview1, wasix };
         const wrap2 = (table) => capturedObject.fromEntries(
-          capturedObject.entries(table).map(([name2, fn]) => [
+          capturedObject.entries(table).map(([name2, fn2]) => [
             name2,
             ((...args) => {
               this.current();
-              const result = fn(...args);
+              const result = fn2(...args);
               this.current();
               return result;
             })
@@ -19623,6 +19643,7 @@ import { runInThisContext } from "node:vm";
 
 // src/node-stack.ts
 init_captured_globals();
+init_raw_stack();
 import { createRequire } from "node:module";
 import { types } from "node:util";
 function quietly(target, run) {
@@ -19635,18 +19656,20 @@ function quietly(target, run) {
     target.emitWarning = emit;
   }
 }
-function positionsOf(load) {
+function bindingOf(load) {
   try {
     const { internalBinding } = quietly(
       capturedprocess,
       () => load("internal/test/binding")
     );
-    const get = internalBinding("errors").getErrorSourcePositions;
-    return typeof get === "function" ? get : void 0;
+    return internalBinding("errors");
   } catch {
-    return void 0;
+    return {};
   }
 }
+function fn(value2) {
+  return typeof value2 === "function" ? value2 : void 0;
+}
 var apply = capturedReflect.apply;
 var push = capturedArray.prototype.push;
 var startsWith = capturedString.prototype.startsWith;
@@ -19657,6 +19680,9 @@ var setHas = capturedSet.prototype.has;
 var setAdd = capturedSet.prototype.add;
 var mapGet = capturedWeakMap.prototype.get;
 var mapSet = capturedWeakMap.prototype.set;
+var mapHas = capturedWeakMap.prototype.has;
+var mapDelete = capturedWeakMap.prototype.delete;
+var MainError = capturedError;
 var isNativeError = types.isNativeError;
 var freeze = capturedObject.freeze;
 var blank = capturedObject.create;
@@ -19669,11 +19695,17 @@ function internals() {
     if (capturedprocess.sourceMapsEnabled) {
       fallback = load("internal/source_map/prepare_stack_trace").prepareStackTraceWithSourceMaps;
     }
-    if (typeof set !== "function" || typeof fallback !== "function") return void 0;
+    const overrides = errors.overrideStackTrace;
+    const usable = typeof set === "function" && typeof fallback === "function";
+    if (!usable || !types.isWeakMap(overrides)) return void 0;
+    const binding = bindingOf(load);
     return {
       setInternalPrepareStackTrace: set,
       fallback,
-      positions: positionsOf(load)
+      positions: fn(binding.getErrorSourcePositions),
+      setCallback: fn(binding.setPrepareStackTraceCallback),
+      overrides,
+      nodeDefault: errors.ErrorPrepareStackTrace
     };
   } catch {
     return void 0;
@@ -19769,6 +19801,7 @@ function keptFrames(trace) {
   return out;
 }
 var formatter = null;
+var withOwn = false;
 var formatting = false;
 var seen = new capturedWeakMap();
 function positionsAt(positions, error, site) {
@@ -19779,17 +19812,20 @@ function positionsAt(positions, error, site) {
     return void 0;
   }
 }
+function record(positions, error, trace) {
+  if (typeof error === "object" && error !== null && trace.length > 0) {
+    const site = trace[0];
+    apply(mapSet, seen, [error, { site, at: positionsAt(positions, error, site) }]);
+  }
+}
 function stackDispatcher(fallback, positions) {
   return (error, trace) => {
-    if (typeof error === "object" && error !== null && trace.length > 0) {
-      const site = trace[0];
-      apply(mapSet, seen, [error, { site, at: positionsAt(positions, error, site) }]);
-    }
-    const fn = formatter;
-    if (fn === null || formatting) return apply(fallback, void 0, [error, trace]);
+    record(positions, error, trace);
+    const fn2 = formatter;
+    if (fn2 === null || formatting) return apply(fallback, void 0, [error, trace]);
     formatting = true;
     try {
-      const out = apply(fn, void 0, [error, keptFrames(trace)]);
+      const out = apply(fn2, void 0, [error, keptFrames(trace)]);
       if (typeof out === "string") return out;
     } catch {
     } finally {
@@ -19798,14 +19834,81 @@ function stackDispatcher(fallback, positions) {
     return apply(fallback, void 0, [error, trace]);
   };
 }
+function errorOf(realm) {
+  return realm === null || realm === void 0 ? void 0 : realm.Error;
+}
+function prepareOf(holder) {
+  return holder === null || holder === void 0 ? void 0 : holder.prepareStackTrace;
+}
+function ownPrepare(realm, nodeDefault) {
+  let self2;
+  if (typeof prepareOf(errorOf(realm)) === "function") self2 = errorOf(realm);
+  else if (typeof prepareOf(MainError) === "function") self2 = MainError;
+  else return void 0;
+  const value2 = prepareOf(self2);
+  return value2 === nodeDefault ? void 0 : { fn: value2, self: self2 };
+}
+function calling(run) {
+  formatting = true;
+  try {
+    return run();
+  } finally {
+    formatting = false;
+  }
+}
+function kernelCallback(internal2, dispatch) {
+  const { fallback, positions, overrides, nodeDefault } = internal2;
+  return (realm, error, trace) => {
+    if (apply(mapHas, overrides, [error]) === true) {
+      const override = apply(mapGet, overrides, [error]);
+      apply(mapDelete, overrides, [error]);
+      return apply(override, void 0, [error, trace]);
+    }
+    const own2 = ownPrepare(realm, nodeDefault);
+    if (formatting) return apply(fallback, void 0, [error, keptFrames(trace)]);
+    const fmt = formatter;
+    if (fmt !== null && withOwn) {
+      record(positions, error, trace);
+      return calling(() => apply(fmt, void 0, [error, keptFrames(trace), own2?.fn]));
+    }
+    if (own2 === void 0) return apply(dispatch, void 0, [error, trace]);
+    record(positions, error, trace);
+    return calling(() => apply(own2.fn, own2.self, [error, keptFrames(trace)]));
+  };
+}
+function rawReader(overrides, fallback) {
+  return (error) => {
+    apply(mapSet, overrides, [
+      error,
+      (e, trace) => apply(fallback, void 0, [e, trace])
+    ]);
+    try {
+      return error.stack;
+    } finally {
+      apply(mapDelete, overrides, [error]);
+    }
+  };
+}
 var found = internals();
-if (found) found.setInternalPrepareStackTrace(stackDispatcher(found.fallback, found.positions));
-var nodeStackFormatter = found ? (fn) => {
-  if (fn !== null && typeof fn !== "function") {
+if (found) {
+  const dispatch = stackDispatcher(found.fallback, found.positions);
+  found.setInternalPrepareStackTrace(dispatch);
+  if (found.setCallback) {
+    found.setCallback(kernelCallback(found, dispatch));
+    setRawStack(rawReader(found.overrides, found.fallback));
+  }
+}
+var nodeStackFormatter = found ? (next2, options) => {
+  if (next2 !== null && typeof next2 !== "function") {
     throw new capturedTypeError("setStackFormatter needs a function or null");
   }
+  const own2 = options === void 0 ? false : options.own;
+  if (typeof own2 !== "boolean" && own2 !== void 0) {
+    throw new capturedTypeError("setStackFormatter: own must be a boolean");
+  }
   const previous = formatter;
-  formatter = fn;
+  formatter = next2;
+  withOwn = next2 !== null && own2 === true;
   return previous;
 } : void 0;
 function errorSourceOf(error) {
@@ -20153,9 +20256,9 @@ function nodeAsyncContext() {
   const getStore = storage.getStore.bind(storage);
   const enterWith = storage.enterWith.bind(storage);
   const api = blank2(null);
-  api.run = freeze2((store, fn, ...args) => {
-    if (typeof fn !== "function") throw new capturedTypeError("asyncContext.run needs a function");
-    return run(store, () => apply2(fn, void 0, args));
+  api.run = freeze2((store, fn2, ...args) => {
+    if (typeof fn2 !== "function") throw new capturedTypeError("asyncContext.run needs a function");
+    return run(store, () => apply2(fn2, void 0, args));
   });
   api.getStore = freeze2(() => getStore());
   api.enterWith = freeze2((store) => enterWith(store));
@@ -20170,6 +20273,7 @@ init_captured_globals();
 init_cpu_clock();
 init_protocol();
 init_process_runtime();
+init_raw_stack();
 var loadWasi = () => Promise.resolve().then(() => (init_wasi_runtime(), wasi_runtime_exports));
 var loadJs = () => Promise.resolve().then(() => (init_js_runtime(), js_runtime_exports));
 var NOT_RUNNABLE2 = 126;
@@ -20186,7 +20290,7 @@ function processEntry(port3, run = runWasmProcess, wasi = loadWasi, js = loadJs,
 }) {
   const failed5 = (err, code2) => port3.postMessage({
     type: WASM_PROCESS_ERROR,
-    message: err instanceof capturedError ? err.stack ?? err.message : capturedString(err),
+    message: err instanceof capturedError ? rawStack(err) ?? err.message : capturedString(err),
     ...code2 === void 0 ? {} : { code: code2 }
   });
   let refused3;