@jerryan/just-bash 3.6.0 → 3.7.0

package/dist/bundle/chunks/js-exec-worker.js

@@ -1652,6 +1652,16 @@ var OpCode = {
   REALPATH: 13,
   RENAME: 14,
   COPY_FILE: 15,
+  // Ranged variant for write payloads larger than the data buffer.
+  // FLAGS carries the file offset (uint32); the chunk length is its
+  // DATA_LENGTH. (Reads use plain READ_FILE plus the generic
+  // READ_RESULT_RANGE assembly; only the write direction needs this.)
+  WRITE_FILE_RANGE: 17,
+  // Fetch the next slice of an oversized result (any op). The host
+  // publishes the first DATA_BUFFER bytes with the FULL length in
+  // RESULT_LENGTH and retains the complete buffer; the worker loops
+  // this op (FLAGS = offset, MODE = length) to assemble the rest.
+  READ_RESULT_RANGE: 18,
   // Special operations for I/O
   WRITE_STDOUT: 100,
   WRITE_STDERR: 101,
@@ -1663,11 +1673,18 @@ var OpCode = {
   // Tool invocation (executor mode)
   INVOKE_TOOL: 400
 };
-var Status = {
-  PENDING: 0,
-  READY: 1,
-  SUCCESS: 2,
-  ERROR: 3
+var RequestState = {
+  IDLE: 0,
+  /** Worker has published an op. */
+  REQUEST: 1,
+  /** stop() cancellation wake. The host treats any non-REQUEST wake as
+   * loop-abort (stop() also flips its `running` flag). */
+  CANCELLED: 2
+};
+var ResultState = {
+  NONE: 0,
+  SUCCESS: 1,
+  ERROR: 2
 };
 var ErrorCode = {
   NONE: 0,
@@ -1678,32 +1695,65 @@ var ErrorCode = {
   PERMISSION_DENIED: 5,
   INVALID_PATH: 6,
   IO_ERROR: 7,
-  TIMEOUT: 8,
   NETWORK_ERROR: 9,
-  NETWORK_NOT_CONFIGURED: 10
+  NETWORK_NOT_CONFIGURED: 10,
+  NOT_EMPTY: 11,
+  LOOP: 12,
+  FILE_TOO_LARGE: 13,
+  NO_SPACE: 14,
+  BUSY: 15,
+  READ_ONLY: 16,
+  CROSS_DEVICE: 17
 };
+var ERRNO_TO_WIRE = Object.assign(
+  /* @__PURE__ */ Object.create(null),
+  {
+    ENOENT: ErrorCode.NOT_FOUND,
+    EISDIR: ErrorCode.IS_DIRECTORY,
+    ENOTDIR: ErrorCode.NOT_DIRECTORY,
+    ENOTEMPTY: ErrorCode.NOT_EMPTY,
+    EEXIST: ErrorCode.EXISTS,
+    EPERM: ErrorCode.PERMISSION_DENIED,
+    EACCES: ErrorCode.PERMISSION_DENIED,
+    EINVAL: ErrorCode.INVALID_PATH,
+    ELOOP: ErrorCode.LOOP,
+    EFBIG: ErrorCode.FILE_TOO_LARGE,
+    ENOSPC: ErrorCode.NO_SPACE,
+    EBUSY: ErrorCode.BUSY,
+    EROFS: ErrorCode.READ_ONLY,
+    EXDEV: ErrorCode.CROSS_DEVICE
+  }
+);
+var WIRE_TO_ERRNO = /* @__PURE__ */ Object.create(null);
+for (const [name, code] of Object.entries(ERRNO_TO_WIRE)) {
+  WIRE_TO_ERRNO[code] = name;
+}
+function wireToErrnoName(code) {
+  return Object.hasOwn(WIRE_TO_ERRNO, code) ? WIRE_TO_ERRNO[code] : void 0;
+}
 var Offset = {
   OP_CODE: 0,
-  STATUS: 4,
+  REQUEST: 4,
   PATH_LENGTH: 8,
   DATA_LENGTH: 12,
   RESULT_LENGTH: 16,
   ERROR_CODE: 20,
   FLAGS: 24,
   MODE: 28,
-  PATH_BUFFER: 32,
-  DATA_BUFFER: 4128
-  // 32 + 4096
+  RESULT_STATE: 32,
+  PATH_BUFFER: 36,
+  DATA_BUFFER: 4132
+  // 36 + 4096
 };
 var Size = {
-  CONTROL_REGION: 32,
   PATH_BUFFER: 4096,
-  // 8MB limit for FS read/write, HTTP responses, and tool invocation results.
-  // Sized to handle typical OpenAPI/GraphQL responses (paginated lists, batch queries).
-  // Still well under the 64MB QuickJS memory limit per execution.
+  // 8MB transfer CHUNK size — not a semantic cap. Results larger than
+  // this are assembled transparently (READ_RESULT_RANGE), and large
+  // writes stream as WRITE_FILE_RANGE chunks. Sized to keep ordinary
+  // ops single-transfer while bounding per-transfer copies.
   DATA_BUFFER: 8388608,
-  TOTAL: 8392736
-  // 32 + 4096 + 8MB
+  TOTAL: 8392740
+  // 36 + 4096 + 8MB
 };
 var Flags = {
   NONE: 0,
@@ -1735,11 +1785,23 @@ var ProtocolBuffer = class {
   setOpCode(code) {
     _Atomics.store(this.int32View, Offset.OP_CODE / 4, code);
   }
-  getStatus() {
-    return _Atomics.load(this.int32View, Offset.STATUS / 4);
+  getRequest() {
+    return _Atomics.load(
+      this.int32View,
+      Offset.REQUEST / 4
+    );
+  }
+  setRequest(request) {
+    _Atomics.store(this.int32View, Offset.REQUEST / 4, request);
+  }
+  getResultState() {
+    return _Atomics.load(
+      this.int32View,
+      Offset.RESULT_STATE / 4
+    );
   }
-  setStatus(status) {
-    _Atomics.store(this.int32View, Offset.STATUS / 4, status);
+  setResultState(state) {
+    _Atomics.store(this.int32View, Offset.RESULT_STATE / 4, state);
   }
   getPathLength() {
     return _Atomics.load(this.int32View, Offset.PATH_LENGTH / 4);
@@ -1832,6 +1894,20 @@ var ProtocolBuffer = class {
     this.uint8View.set(data, Offset.DATA_BUFFER);
     this.setResultLength(data.length);
   }
+  /**
+   * Publish a result of ANY size: the first DATA_BUFFER bytes land in
+   * the data region and RESULT_LENGTH carries the FULL length. The
+   * worker detects the overflow and fetches the rest with
+   * READ_RESULT_RANGE ops (served from the host's retained buffer).
+   */
+  setResultPrefix(data) {
+    if (data.length > 2147483647) {
+      throw new Error(`Result too large: ${data.length} exceeds int32`);
+    }
+    const n = Math.min(data.length, Size.DATA_BUFFER);
+    this.uint8View.set(data.subarray(0, n), Offset.DATA_BUFFER);
+    this.setResultLength(data.length);
+  }
   getResultAsString() {
     const result = this.getResult();
     return new TextDecoder().decode(result);
@@ -1873,33 +1949,21 @@ var ProtocolBuffer = class {
       )
     };
   }
-  waitForReady(timeout) {
-    return _Atomics.wait(
-      this.int32View,
-      Offset.STATUS / 4,
-      Status.PENDING,
-      timeout
-    );
-  }
-  waitForReadyAsync(timeout) {
-    return _Atomics.waitAsync(
-      this.int32View,
-      Offset.STATUS / 4,
-      Status.PENDING,
-      timeout
-    );
-  }
   /**
-   * Wait for status to become READY.
-   * Returns immediately if status is already READY, or waits until it changes.
+   * Wait for the request word to become REQUEST.
+   * Returns immediately if already REQUEST; CANCELLED or any unexpected
+   * state returns false (the caller's running-flag check aborts the loop).
    */
   async waitUntilReady(timeout) {
     const startTime = Date.now();
     while (true) {
-      const status = this.getStatus();
-      if (status === Status.READY) {
+      const request = this.getRequest();
+      if (request === RequestState.REQUEST) {
         return true;
       }
+      if (request !== RequestState.IDLE) {
+        return false;
+      }
       const elapsed = Date.now() - startTime;
       if (elapsed >= timeout) {
         return false;
@@ -1907,8 +1971,8 @@ var ProtocolBuffer = class {
       const remainingMs = timeout - elapsed;
       const result = _Atomics.waitAsync(
         this.int32View,
-        Offset.STATUS / 4,
-        status,
+        Offset.REQUEST / 4,
+        RequestState.IDLE,
         remainingMs
       );
       if (result.async) {
@@ -1919,20 +1983,25 @@ var ProtocolBuffer = class {
       }
     }
   }
+  /** Worker-side blocking wait on the RESULT word (host writes). */
   waitForResult(timeout) {
     return _Atomics.wait(
       this.int32View,
-      Offset.STATUS / 4,
-      Status.READY,
+      Offset.RESULT_STATE / 4,
+      ResultState.NONE,
       timeout
     );
   }
-  notify() {
-    return _Atomics.notify(this.int32View, Offset.STATUS / 4);
+  notifyRequest() {
+    return _Atomics.notify(this.int32View, Offset.REQUEST / 4);
+  }
+  notifyResult() {
+    return _Atomics.notify(this.int32View, Offset.RESULT_STATE / 4);
   }
   reset() {
     this.setOpCode(OpCode.NOOP);
-    this.setStatus(Status.PENDING);
+    this.setRequest(RequestState.IDLE);
+    this.setResultState(ResultState.NONE);
     this.setPathLength(0);
     this.setDataLength(0);
     this.setResultLength(0);
@@ -1959,52 +2028,117 @@ var SyncBackend = class {
     if (data) {
       this.protocol.setData(data);
     }
-    this.protocol.setStatus(Status.READY);
-    this.protocol.notify();
+    this.protocol.setRequest(RequestState.REQUEST);
+    this.protocol.notifyRequest();
     const waitResult = this.protocol.waitForResult(this.operationTimeoutMs);
     if (waitResult === "timed-out") {
       return { success: false, error: "Operation timed out" };
     }
-    const status = this.protocol.getStatus();
-    if (status === Status.SUCCESS) {
-      return { success: true, result: this.protocol.getResult() };
+    const resultState = this.protocol.getResultState();
+    if (resultState === ResultState.SUCCESS) {
+      const totalLength = this.protocol.getResultLength();
+      if (totalLength <= Size.DATA_BUFFER) {
+        return { success: true, result: this.protocol.getResult() };
+      }
+      const content = new Uint8Array(totalLength);
+      content.set(this.protocol.getResult().subarray(0, Size.DATA_BUFFER), 0);
+      let offset = Size.DATA_BUFFER;
+      while (offset < totalLength) {
+        const length = Math.min(Size.DATA_BUFFER, totalLength - offset);
+        const slice = this.execSync(
+          OpCode.READ_RESULT_RANGE,
+          "",
+          void 0,
+          offset,
+          length
+        );
+        if (!slice.success) {
+          throw this.opError_("Failed to read result range", slice);
+        }
+        const chunk = slice.result ?? new Uint8Array(0);
+        content.set(chunk, offset);
+        offset += chunk.length;
+        if (chunk.length === 0) {
+          throw this.opError_("bridge returned an empty result slice", slice);
+        }
+      }
+      return { success: true, result: content };
+    }
+    if (resultState === ResultState.ERROR) {
+      return {
+        success: false,
+        error: this.protocol.getResultAsString() || // Impossible by construction: every host error path publishes a
+        // code and message. If this ever fires, the diagnostic payload
+        // must identify the exact protocol state.
+        `bridge protocol violation: op ${opCode} ERROR with empty message (wait=${waitResult}, errorCode=${this.protocol.getErrorCode()})`,
+        errorCode: this.protocol.getErrorCode()
+      };
     }
     return {
       success: false,
-      error: this.protocol.getResultAsString() || `Error code: ${this.protocol.getErrorCode()}`
+      error: `bridge protocol violation: op ${opCode} woke with resultState ${resultState} (wait=${waitResult}, errorCode=${this.protocol.getErrorCode()})`,
+      errorCode: this.protocol.getErrorCode()
     };
   }
+  /** Build an op failure that preserves the bridge's numeric error code,
+   * so downstream errno mapping prefers it over substring matching. */
+  opError_(fallback, result) {
+    const err = new Error(result.error || fallback);
+    err.bridgeErrorCode = result.errorCode;
+    if (result.errorCode !== void 0) {
+      const name = wireToErrnoName(result.errorCode);
+      if (name !== void 0) err.code = name;
+    }
+    return err;
+  }
   readFile(path) {
     const result = this.execSync(OpCode.READ_FILE, path);
     if (!result.success) {
-      throw new Error(result.error || "Failed to read file");
+      throw this.opError_("Failed to read file", result);
     }
     return result.result ?? new Uint8Array(0);
   }
   writeFile(path, data) {
-    const result = this.execSync(OpCode.WRITE_FILE, path, data);
-    if (!result.success) {
-      throw new Error(result.error || "Failed to write file");
+    if (data.length <= Size.DATA_BUFFER) {
+      const result = this.execSync(OpCode.WRITE_FILE, path, data);
+      if (!result.success) {
+        throw this.opError_("Failed to write file", result);
+      }
+      return;
+    }
+    let offset = 0;
+    while (offset < data.length) {
+      const chunk = data.subarray(offset, offset + Size.DATA_BUFFER);
+      const result = this.execSync(
+        OpCode.WRITE_FILE_RANGE,
+        path,
+        chunk,
+        offset
+      );
+      if (!result.success) {
+        throw this.opError_("Failed to write file", result);
+      }
+      offset += chunk.length;
     }
   }
   stat(path) {
     const result = this.execSync(OpCode.STAT, path);
     if (!result.success) {
-      throw new Error(result.error || "Failed to stat");
+      throw this.opError_("Failed to stat", result);
     }
     return this.protocol.decodeStat();
   }
   lstat(path) {
     const result = this.execSync(OpCode.LSTAT, path);
     if (!result.success) {
-      throw new Error(result.error || "Failed to lstat");
+      throw this.opError_("Failed to lstat", result);
     }
     return this.protocol.decodeStat();
   }
   readdir(path) {
     const result = this.execSync(OpCode.READDIR, path);
     if (!result.success) {
-      throw new Error(result.error || "Failed to readdir");
+      throw this.opError_("Failed to readdir", result);
     }
     return JSON.parse(this.protocol.getResultAsString());
   }
@@ -2012,7 +2146,7 @@ var SyncBackend = class {
     const flags = recursive ? Flags.MKDIR_RECURSIVE : 0;
     const result = this.execSync(OpCode.MKDIR, path, void 0, flags);
     if (!result.success) {
-      throw new Error(result.error || "Failed to mkdir");
+      throw this.opError_("Failed to mkdir", result);
     }
   }
   rm(path, recursive = false, force = false) {
@@ -2021,7 +2155,7 @@ var SyncBackend = class {
     if (force) flags |= Flags.FORCE;
     const result = this.execSync(OpCode.RM, path, void 0, flags);
     if (!result.success) {
-      throw new Error(result.error || "Failed to rm");
+      throw this.opError_("Failed to rm", result);
     }
   }
   exists(path) {
@@ -2034,33 +2168,33 @@ var SyncBackend = class {
   appendFile(path, data) {
     const result = this.execSync(OpCode.APPEND_FILE, path, data);
     if (!result.success) {
-      throw new Error(result.error || "Failed to append file");
+      throw this.opError_("Failed to append file", result);
     }
   }
   symlink(target, linkPath) {
     const targetData = new TextEncoder().encode(target);
     const result = this.execSync(OpCode.SYMLINK, linkPath, targetData);
     if (!result.success) {
-      throw new Error(result.error || "Failed to symlink");
+      throw this.opError_("Failed to symlink", result);
     }
   }
   readlink(path) {
     const result = this.execSync(OpCode.READLINK, path);
     if (!result.success) {
-      throw new Error(result.error || "Failed to readlink");
+      throw this.opError_("Failed to readlink", result);
     }
     return this.protocol.getResultAsString();
   }
   chmod(path, mode) {
     const result = this.execSync(OpCode.CHMOD, path, void 0, 0, mode);
     if (!result.success) {
-      throw new Error(result.error || "Failed to chmod");
+      throw this.opError_("Failed to chmod", result);
     }
   }
   realpath(path) {
     const result = this.execSync(OpCode.REALPATH, path);
     if (!result.success) {
-      throw new Error(result.error || "Failed to realpath");
+      throw this.opError_("Failed to realpath", result);
     }
     return this.protocol.getResultAsString();
   }
@@ -2068,28 +2202,28 @@ var SyncBackend = class {
     const newPathData = new TextEncoder().encode(newPath);
     const result = this.execSync(OpCode.RENAME, oldPath, newPathData);
     if (!result.success) {
-      throw new Error(result.error || "Failed to rename");
+      throw this.opError_("Failed to rename", result);
     }
   }
   copyFile(src, dest) {
     const destData = new TextEncoder().encode(dest);
     const result = this.execSync(OpCode.COPY_FILE, src, destData);
     if (!result.success) {
-      throw new Error(result.error || "Failed to copyFile");
+      throw this.opError_("Failed to copyFile", result);
     }
   }
   writeStdout(data) {
     const encoded = new TextEncoder().encode(data);
     const result = this.execSync(OpCode.WRITE_STDOUT, "", encoded);
     if (!result.success) {
-      throw new Error(result.error || "Failed to write stdout");
+      throw this.opError_("Failed to write stdout", result);
     }
   }
   writeStderr(data) {
     const encoded = new TextEncoder().encode(data);
     const result = this.execSync(OpCode.WRITE_STDERR, "", encoded);
     if (!result.success) {
-      throw new Error(result.error || "Failed to write stderr");
+      throw this.opError_("Failed to write stderr", result);
     }
   }
   exit(code) {
@@ -2103,7 +2237,7 @@ var SyncBackend = class {
     const requestData = options ? new TextEncoder().encode(JSON.stringify(options)) : void 0;
     const result = this.execSync(OpCode.HTTP_REQUEST, url, requestData);
     if (!result.success) {
-      throw new Error(result.error || "HTTP request failed");
+      throw this.opError_("HTTP request failed", result);
     }
     const responseJson = new TextDecoder().decode(result.result);
     const parsed = JSON.parse(responseJson);
@@ -2126,7 +2260,7 @@ var SyncBackend = class {
     const requestData = stdin ? new TextEncoder().encode(JSON.stringify({ stdin })) : void 0;
     const result = this.execSync(OpCode.EXEC_COMMAND, command, requestData);
     if (!result.success) {
-      throw new Error(result.error || "Command execution failed");
+      throw this.opError_("Command execution failed", result);
     }
     const responseJson = new TextDecoder().decode(result.result);
     return JSON.parse(responseJson);
@@ -2139,7 +2273,7 @@ var SyncBackend = class {
     const requestData = new TextEncoder().encode(JSON.stringify({ args }));
     const result = this.execSync(OpCode.EXEC_COMMAND, command, requestData);
     if (!result.success) {
-      throw new Error(result.error || "Command execution failed");
+      throw this.opError_("Command execution failed", result);
     }
     const responseJson = new TextDecoder().decode(result.result);
     return JSON.parse(responseJson);
@@ -2152,7 +2286,7 @@ var SyncBackend = class {
     const requestData = argsJson ? new TextEncoder().encode(argsJson) : void 0;
     const result = this.execSync(OpCode.INVOKE_TOOL, path, requestData);
     if (!result.success) {
-      throw new Error(result.error || "Tool invocation failed");
+      throw this.opError_("Tool invocation failed", result);
     }
     return new TextDecoder().decode(result.result);
   }
@@ -3571,8 +3705,18 @@ function formatError(errorVal) {
   }
   return String(errorVal);
 }
-function throwError(context, message) {
-  return { error: context.newError(message) };
+function throwError(context, message, code) {
+  const err = context.newError(message);
+  if (code !== void 0) {
+    const codeHandle = context.newString(code);
+    context.setProp(err, "code", codeHandle);
+    codeHandle.dispose();
+  }
+  return { error: err };
+}
+function throwGuestError_(context, e, fallback) {
+  const err = e;
+  return throwError(context, err?.message || fallback, err?.code);
 }
 function isProcessExit(context, error, processExitMarker) {
   const marker = context.getProp(error, PROCESS_EXIT_MARKER);
@@ -3816,7 +3960,7 @@ function setupContext(context, backend, input, processExitMarker) {
       backend.writeStdout(`${parts.join(" ")}
 `);
     } catch (e) {
-      return throwError(context, e.message || "write failed");
+      return throwGuestError_(context, e, "write failed");
     }
     return context.undefined;
   });
@@ -3831,7 +3975,7 @@ function setupContext(context, backend, input, processExitMarker) {
       backend.writeStderr(`${parts.join(" ")}
 `);
     } catch (e) {
-      return throwError(context, e.message || "write failed");
+      return throwGuestError_(context, e, "write failed");
     }
     return context.undefined;
   });
@@ -3846,7 +3990,7 @@ function setupContext(context, backend, input, processExitMarker) {
       backend.writeStderr(`${parts.join(" ")}
 `);
     } catch (e) {
-      return throwError(context, e.message || "write failed");
+      return throwGuestError_(context, e, "write failed");
     }
     return context.undefined;
   });
@@ -3863,7 +4007,7 @@ function setupContext(context, backend, input, processExitMarker) {
         const data = backend.readFile(path);
         return context.newString(new TextDecoder().decode(data));
       } catch (e) {
-        return throwError(context, e.message || "readFile failed");
+        return throwGuestError_(context, e, "readFile failed");
       }
     }
   );
@@ -3879,25 +4023,56 @@ function setupContext(context, backend, input, processExitMarker) {
           data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength)
         );
       } catch (e) {
-        return throwError(
-          context,
-          e.message || "readFileBuffer failed"
-        );
+        return throwGuestError_(context, e, "readFileBuffer failed");
       }
     }
   );
   context.setProp(fsObj, "readFileBuffer", readFileBufferFn);
   readFileBufferFn.dispose();
+  const marshalWriteData = (dataHandle) => {
+    if (context.typeof(dataHandle) === "string") {
+      return new TextEncoder().encode(context.getString(dataHandle));
+    }
+    if (context.typeof(dataHandle) === "object") {
+      const bufferHandle = context.getProp(dataHandle, "buffer");
+      if (bufferHandle && context.typeof(bufferHandle) === "object") {
+        const offsetHandle = context.getProp(dataHandle, "byteOffset");
+        const lengthHandle = context.getProp(dataHandle, "byteLength");
+        try {
+          const raw = context.getArrayBuffer(bufferHandle).value;
+          const view = raw instanceof Uint8Array ? raw : new Uint8Array(raw);
+          const offset = offsetHandle && context.typeof(offsetHandle) === "number" ? context.getNumber(offsetHandle) : 0;
+          const length = lengthHandle && context.typeof(lengthHandle) === "number" ? context.getNumber(lengthHandle) : view.byteLength - offset;
+          if (offset < 0 || length < 0 || offset + length > view.byteLength) {
+            throw new TypeError("writeFile data has an invalid byte window");
+          }
+          return view.slice(offset, offset + length);
+        } finally {
+          bufferHandle.dispose();
+          offsetHandle?.dispose();
+          lengthHandle?.dispose();
+        }
+      }
+      bufferHandle?.dispose();
+      try {
+        const raw = context.getArrayBuffer(dataHandle).value;
+        return raw instanceof Uint8Array ? raw : new Uint8Array(raw);
+      } catch {
+      }
+    }
+    throw new TypeError(
+      "writeFile data must be a string, Buffer, TypedArray, or DataView"
+    );
+  };
   const writeFileFn = context.newFunction(
     "writeFile",
     (pathHandle, dataHandle) => {
       const path = context.getString(pathHandle);
-      const data = context.getString(dataHandle);
       try {
-        backend.writeFile(path, new TextEncoder().encode(data));
+        backend.writeFile(path, marshalWriteData(dataHandle));
         return context.undefined;
       } catch (e) {
-        return throwError(context, e.message || "writeFile failed");
+        return throwGuestError_(context, e, "writeFile failed");
       }
     }
   );
@@ -3916,7 +4091,7 @@ function setupContext(context, backend, input, processExitMarker) {
         mtime: stat.mtime.toISOString()
       });
     } catch (e) {
-      return throwError(context, e.message || "stat failed");
+      return throwGuestError_(context, e, "stat failed");
     }
   });
   context.setProp(fsObj, "stat", statFn);
@@ -3929,7 +4104,7 @@ function setupContext(context, backend, input, processExitMarker) {
         const entries = backend.readdir(path);
         return jsToHandle(context, entries);
       } catch (e) {
-        return throwError(context, e.message || "readdir failed");
+        return throwGuestError_(context, e, "readdir failed");
       }
     }
   );
@@ -3950,7 +4125,7 @@ function setupContext(context, backend, input, processExitMarker) {
         backend.mkdir(path, recursive);
         return context.undefined;
       } catch (e) {
-        return throwError(context, e.message || "mkdir failed");
+        return throwGuestError_(context, e, "mkdir failed");
       }
     }
   );
@@ -3973,7 +4148,7 @@ function setupContext(context, backend, input, processExitMarker) {
         backend.rm(path, recursive, force);
         return context.undefined;
       } catch (e) {
-        return throwError(context, e.message || "rm failed");
+        return throwGuestError_(context, e, "rm failed");
       }
     }
   );
@@ -3992,12 +4167,11 @@ function setupContext(context, backend, input, processExitMarker) {
     "appendFile",
     (pathHandle, dataHandle) => {
       const path = context.getString(pathHandle);
-      const data = context.getString(dataHandle);
       try {
-        backend.appendFile(path, new TextEncoder().encode(data));
+        backend.appendFile(path, marshalWriteData(dataHandle));
         return context.undefined;
       } catch (e) {
-        return throwError(context, e.message || "appendFile failed");
+        return throwGuestError_(context, e, "appendFile failed");
       }
     }
   );
@@ -4016,7 +4190,7 @@ function setupContext(context, backend, input, processExitMarker) {
         mtime: s.mtime.toISOString()
       });
     } catch (e) {
-      return throwError(context, e.message || "lstat failed");
+      return throwGuestError_(context, e, "lstat failed");
     }
   });
   context.setProp(fsObj, "lstat", lstatFn);
@@ -4030,7 +4204,7 @@ function setupContext(context, backend, input, processExitMarker) {
         backend.symlink(target, linkPath);
         return context.undefined;
       } catch (e) {
-        return throwError(context, e.message || "symlink failed");
+        return throwGuestError_(context, e, "symlink failed");
       }
     }
   );
@@ -4044,7 +4218,7 @@ function setupContext(context, backend, input, processExitMarker) {
         const target = backend.readlink(path);
         return context.newString(target);
       } catch (e) {
-        return throwError(context, e.message || "readlink failed");
+        return throwGuestError_(context, e, "readlink failed");
       }
     }
   );
@@ -4059,7 +4233,7 @@ function setupContext(context, backend, input, processExitMarker) {
         backend.chmod(path, typeof mode === "number" ? mode : 0);
         return context.undefined;
       } catch (e) {
-        return throwError(context, e.message || "chmod failed");
+        return throwGuestError_(context, e, "chmod failed");
       }
     }
   );
@@ -4073,7 +4247,7 @@ function setupContext(context, backend, input, processExitMarker) {
         const resolved = backend.realpath(path);
         return context.newString(resolved);
       } catch (e) {
-        return throwError(context, e.message || "realpath failed");
+        return throwGuestError_(context, e, "realpath failed");
       }
     }
   );
@@ -4088,7 +4262,7 @@ function setupContext(context, backend, input, processExitMarker) {
         backend.rename(oldPath, newPath);
         return context.undefined;
       } catch (e) {
-        return throwError(context, e.message || "rename failed");
+        return throwGuestError_(context, e, "rename failed");
       }
     }
   );
@@ -4103,7 +4277,7 @@ function setupContext(context, backend, input, processExitMarker) {
         backend.copyFile(src, dest);
         return context.undefined;
       } catch (e) {
-        return throwError(context, e.message || "copyFile failed");
+        return throwGuestError_(context, e, "copyFile failed");
       }
     }
   );
@@ -4127,7 +4301,7 @@ function setupContext(context, backend, input, processExitMarker) {
         });
         return jsToHandle(context, result);
       } catch (e) {
-        return throwError(context, e.message || "fetch failed");
+        return throwGuestError_(context, e, "fetch failed");
       }
     }
   );
@@ -4148,7 +4322,7 @@ function setupContext(context, backend, input, processExitMarker) {
         const result = backend.execCommand(command, stdin);
         return jsToHandle(context, result);
       } catch (e) {
-        return throwError(context, e.message || "exec failed");
+        return throwGuestError_(context, e, "exec failed");
       }
     }
   );
@@ -4163,7 +4337,7 @@ function setupContext(context, backend, input, processExitMarker) {
         const result = backend.execCommandArgs(command, args);
         return jsToHandle(context, result);
       } catch (e) {
-        return throwError(context, e.message || "exec failed");
+        return throwGuestError_(context, e, "exec failed");
       }
     }
   );
@@ -4179,10 +4353,7 @@ function setupContext(context, backend, input, processExitMarker) {
           const resultJson = backend.invokeTool(path, argsJson);
           return context.newString(resultJson);
         } catch (e) {
-          return throwError(
-            context,
-            e.message || "tool invocation failed"
-          );
+          return throwGuestError_(context, e, "tool invocation failed");
         }
       }
     );
@@ -4310,7 +4481,13 @@ function setupContext(context, backend, input, processExitMarker) {
   _fs.promises.unlink = _fs.promises.rm;
   _fs.promises.rmdir = _fs.promises.rm;
   _fs.promises.access = function(p) {
-    return orig.exists(p) ? Promise.resolve() : Promise.reject(new Error('ENOENT: no such file or directory: ' + p));
+    if (orig.exists(p)) return Promise.resolve();
+    // Node-style error: prefixed message AND structured .code (the
+    // sanctioned pattern \u2014 no errno literal at the Error call site).
+    var msg = 'ENOENT: no such file or directory: ' + p;
+    var e = new Error(msg);
+    e.code = 'ENOENT';
+    return Promise.reject(e);
   };
 
   // process enhancements
@@ -4640,11 +4817,14 @@ async function executeCode(input) {
             }
             return source;
           } catch (e) {
-            return {
-              error: new Error(
-                `Cannot find module '${moduleName}': ${e.message}`
-              )
-            };
+            const err = new Error(
+              `Cannot find module '${moduleName}': ${e.message}`
+            );
+            const code = e.code;
+            if (code !== void 0) {
+              err.code = code;
+            }
+            return { error: err };
           }
         },
         (baseModuleName, requestedName) => {