sandboxedjs 0.1.6 → 0.1.7

package/dist/index.d.cts

@@ -1545,6 +1545,22 @@ declare class Container {
         headers?: Record<string, string>;
         body?: string | Uint8Array;
     }): Promise<HttpResponse>;
+    /**
+     * Deliver a request whose body is bytes, without letting them become text.
+     *
+     * Nodepod's public `request()` runs the body through `toString("utf8")` on
+     * its way in, so anything above `0x7f` is replaced: a five-byte payload
+     * containing `0x89` and `0xff` arrives as nine. That silently destroys every
+     * upload — an image or a video reaches the server the wrong size and no
+     * longer decodes, with no error raised anywhere.
+     *
+     * Its own dispatcher one layer down does preserve bytes, so a binary body
+     * goes straight there. This reaches past the published surface deliberately,
+     * so it is written to fail soft: any shape it does not recognise returns
+     * `null` and the caller falls back to the ordinary path, which is exactly
+     * the behaviour that existed before. Text bodies never come through here.
+     */
+    private dispatchBinary;
     /** Wait until something inside the container answers on `port`. */
     waitForPort(port: number, opts?: {
         timeoutMs?: number;

package/dist/index.d.ts

@@ -1545,6 +1545,22 @@ declare class Container {
         headers?: Record<string, string>;
         body?: string | Uint8Array;
     }): Promise<HttpResponse>;
+    /**
+     * Deliver a request whose body is bytes, without letting them become text.
+     *
+     * Nodepod's public `request()` runs the body through `toString("utf8")` on
+     * its way in, so anything above `0x7f` is replaced: a five-byte payload
+     * containing `0x89` and `0xff` arrives as nine. That silently destroys every
+     * upload — an image or a video reaches the server the wrong size and no
+     * longer decodes, with no error raised anywhere.
+     *
+     * Its own dispatcher one layer down does preserve bytes, so a binary body
+     * goes straight there. This reaches past the published surface deliberately,
+     * so it is written to fail soft: any shape it does not recognise returns
+     * `null` and the caller falls back to the ordinary path, which is exactly
+     * the behaviour that existed before. Text bodies never come through here.
+     */
+    private dispatchBinary;
     /** Wait until something inside the container answers on `port`. */
     waitForPort(port: number, opts?: {
         timeoutMs?: number;

package/dist/index.js

@@ -23976,14 +23976,17 @@ var Container = class _Container {
   /** Send an HTTP request to a server running inside the container. */
   async request(port, init = {}) {
     this.assertActive();
-    const res = await this.pod.request(port, {
+    const res = await this.dispatchBinary(port, init) ?? await this.pod.request(port, {
       method: init.method ?? "GET",
       path: init.path ?? "/",
       headers: init.headers ?? {},
       body: init.body ?? null
     });
     const bodyRaw = res.body;
-    const bytes = bodyRaw instanceof Uint8Array ? bodyRaw : typeof bodyRaw === "string" ? new TextEncoder().encode(bodyRaw) : new Uint8Array(0);
+    const bytes = bodyRaw instanceof Uint8Array ? bodyRaw : (
+      // The binary dispatcher answers with an ArrayBuffer.
+      bodyRaw instanceof ArrayBuffer ? new Uint8Array(bodyRaw) : typeof bodyRaw === "string" ? new TextEncoder().encode(bodyRaw) : new Uint8Array(0)
+    );
     const body = typeof bodyRaw === "string" ? bodyRaw : new TextDecoder().decode(bytes);
     return {
       status: res.statusCode ?? 200,
@@ -23996,6 +23999,40 @@ var Container = class _Container {
       }
     };
   }
+  /**
+   * Deliver a request whose body is bytes, without letting them become text.
+   *
+   * Nodepod's public `request()` runs the body through `toString("utf8")` on
+   * its way in, so anything above `0x7f` is replaced: a five-byte payload
+   * containing `0x89` and `0xff` arrives as nine. That silently destroys every
+   * upload — an image or a video reaches the server the wrong size and no
+   * longer decodes, with no error raised anywhere.
+   *
+   * Its own dispatcher one layer down does preserve bytes, so a binary body
+   * goes straight there. This reaches past the published surface deliberately,
+   * so it is written to fail soft: any shape it does not recognise returns
+   * `null` and the caller falls back to the ordinary path, which is exactly
+   * the behaviour that existed before. Text bodies never come through here.
+   */
+  async dispatchBinary(port, init) {
+    if (!(init.body instanceof Uint8Array)) return null;
+    const manager = this.pod._processManager;
+    const dispatch = manager?.dispatchHttpRequest;
+    if (typeof dispatch !== "function") return null;
+    try {
+      const response = await dispatch.call(
+        manager,
+        port,
+        init.method ?? "GET",
+        init.path ?? "/",
+        init.headers ?? {},
+        init.body
+      );
+      return response ?? null;
+    } catch {
+      return null;
+    }
+  }
   /** Wait until something inside the container answers on `port`. */
   waitForPort(port, opts = {}) {
     return this.net.waitForPort(port, opts);