@jerryan/just-bash 3.6.0 → 3.7.0

package/dist/bundle/chunks/worker.js

@@ -1690,6 +1690,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,
@@ -1701,11 +1711,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,
@@ -1716,32 +1733,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,
@@ -1773,11 +1823,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);
@@ -1870,6 +1932,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);
@@ -1911,33 +1987,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;
@@ -1945,8 +2009,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) {
@@ -1957,20 +2021,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);
@@ -1997,52 +2066,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());
   }
@@ -2050,7 +2184,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) {
@@ -2059,7 +2193,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) {
@@ -2072,33 +2206,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();
   }
@@ -2106,28 +2240,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) {
@@ -2141,7 +2275,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);
@@ -2164,7 +2298,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);
@@ -2177,7 +2311,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);
@@ -2190,7 +2324,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);
   }
@@ -2202,14 +2336,14 @@ var require2 = createRequire(import.meta.url);
 var CPYTHON_ENTRY_BASENAME = "/vendor/cpython-emscripten/python.cjs";
 var CPYTHON_STDLIB_BASENAME = "/vendor/cpython-emscripten/python313.zip";
 var moduleLoadGuardInstalled = false;
-function normalizePath(path) {
+function normalizeSeparators(path) {
   return path.replace(/\\/g, "/");
 }
 function isApprovedCpythonEntryPath(path) {
-  return normalizePath(path).endsWith(CPYTHON_ENTRY_BASENAME);
+  return normalizeSeparators(path).endsWith(CPYTHON_ENTRY_BASENAME);
 }
 function isApprovedStdlibZipPath(path) {
-  return normalizePath(path).endsWith(CPYTHON_STDLIB_BASENAME);
+  return normalizeSeparators(path).endsWith(CPYTHON_STDLIB_BASENAME);
 }
 function assertApprovedPath(path, kind) {
   const ok = kind === "cpython-entry" ? isApprovedCpythonEntryPath(path) : isApprovedStdlibZipPath(path);
@@ -2289,26 +2423,20 @@ function createHOSTFS(backend, FS, PATH, configuredMaxFileSize) {
   const ERRNO_CODES = Object.assign(
     /* @__PURE__ */ Object.create(null),
     {
-      EPERM: 63,
       ENOENT: 44,
       EIO: 29,
-      EBADF: 8,
-      EAGAIN: 6,
       EACCES: 2,
       EBUSY: 10,
       EEXIST: 20,
       ENOTDIR: 54,
       EISDIR: 31,
+      ELOOP: 32,
       EINVAL: 28,
       EFBIG: 27,
-      EMFILE: 33,
       ENOSPC: 51,
-      ESPIPE: 70,
       EROFS: 69,
-      ENOTEMPTY: 55,
-      ENOSYS: 52,
-      ENOTSUP: 138,
-      ENODATA: 42
+      EXDEV: 75,
+      ENOTEMPTY: 55
     }
   );
   function realPath(node) {
@@ -2321,26 +2449,22 @@ function createHOSTFS(backend, FS, PATH, configuredMaxFileSize) {
     parts.reverse();
     return PATH.join(...parts);
   }
+  function errnoFromError(e) {
+    const bridgeCode = e?.bridgeErrorCode;
+    if (typeof bridgeCode === "number" && bridgeCode !== ErrorCode.NONE) {
+      const name = wireToErrnoName(bridgeCode);
+      if (name !== void 0 && Object.hasOwn(ERRNO_CODES, name)) {
+        return ERRNO_CODES[name];
+      }
+      return ERRNO_CODES.EIO;
+    }
+    return ERRNO_CODES.EIO;
+  }
   function tryFSOperation(f) {
     try {
       return f();
     } catch (e) {
-      const msg = e?.message?.toLowerCase() || (typeof e === "string" ? e.toLowerCase() : "");
-      let code = ERRNO_CODES.EIO;
-      if (msg.includes("no such file") || msg.includes("not found")) {
-        code = ERRNO_CODES.ENOENT;
-      } else if (msg.includes("is a directory")) {
-        code = ERRNO_CODES.EISDIR;
-      } else if (msg.includes("not a directory")) {
-        code = ERRNO_CODES.ENOTDIR;
-      } else if (msg.includes("already exists")) {
-        code = ERRNO_CODES.EEXIST;
-      } else if (msg.includes("permission")) {
-        code = ERRNO_CODES.EACCES;
-      } else if (msg.includes("not empty")) {
-        code = ERRNO_CODES.ENOTEMPTY;
-      }
-      throw new FS.ErrnoError(code);
+      throw new FS.ErrnoError(errnoFromError(e));
     }
   }
   function getMode(path) {
@@ -2491,11 +2615,12 @@ function createHOSTFS(backend, FS, PATH, configuredMaxFileSize) {
           } else {
             content = backend.readFile(path);
           }
-        } catch (_e) {
-          if (isCreate && isWrite) {
+        } catch (e) {
+          const code = errnoFromError(e);
+          if (code === ERRNO_CODES.ENOENT && isCreate && isWrite) {
             content = new Uint8Array(0);
           } else {
-            throw new FS.ErrnoError(ERRNO_CODES.ENOENT);
+            throw new FS.ErrnoError(code);
           }
         }
         if (content.length > maxFileSize) {
@@ -3282,7 +3407,7 @@ function activateDefense(protocolToken) {
   );
   defense = new WorkerDefenseInDepth({
     excludeViolationTypes: [
-      // SharedArrayBuffer/Atomics: Used by sync-fs-backend.ts for synchronous
+      // SharedArrayBuffer/Atomics: Used by worker-bridge/sync-backend.ts for synchronous
       // filesystem communication between the WASM thread and the main thread.
       "shared_array_buffer",
       "atomics",