@schmock/core 2.2.2 → 2.3.0

package/dist/interceptor.js

@@ -1,5 +1,65 @@
 /// <reference path="../schmock.d.ts" />
+import { isBinaryBody } from "./binary.js";
 import { isRouteNotFound, toHttpMethod } from "./constants.js";
+const PASSTHROUGH = Symbol("schmock.fetch.passthrough");
+function toFetchBinaryBody(body) {
+    if (body instanceof ArrayBuffer)
+        return body;
+    const bytes = new Uint8Array(body.byteLength);
+    bytes.set(new Uint8Array(body.buffer, body.byteOffset, body.byteLength));
+    return bytes;
+}
+let activeSession;
+function createInterceptorSession() {
+    const baselineFetch = globalThis.fetch;
+    const interceptors = [];
+    const dispatchFetch = async (input, init) => {
+        const snapshot = interceptors.slice();
+        for (let index = snapshot.length - 1; index >= 0; index -= 1) {
+            const result = await snapshot[index].intercept(input, init);
+            if (result !== PASSTHROUGH) {
+                return result;
+            }
+        }
+        return baselineFetch(input, init);
+    };
+    return { baselineFetch, dispatchFetch, interceptors };
+}
+function registerInterceptor(intercept) {
+    let session = activeSession;
+    if (!session || globalThis.fetch !== session.dispatchFetch) {
+        session = createInterceptorSession();
+        activeSession = session;
+        globalThis.fetch = session.dispatchFetch;
+    }
+    const token = Symbol("schmock.fetch.interceptor");
+    session.interceptors.push({ token, intercept });
+    let active = true;
+    return {
+        restore() {
+            if (!active)
+                return;
+            active = false;
+            const index = session.interceptors.findIndex((entry) => entry.token === token);
+            if (index !== -1) {
+                session.interceptors.splice(index, 1);
+            }
+            if (session.interceptors.length !== 0)
+                return;
+            if (activeSession === session) {
+                activeSession = undefined;
+            }
+            // A library may have installed its own fetch wrapper after Schmock. Its
+            // replacement is now the current owner and must not be overwritten.
+            if (globalThis.fetch === session.dispatchFetch) {
+                globalThis.fetch = session.baselineFetch;
+            }
+        },
+        get active() {
+            return active;
+        },
+    };
+}
 /**
  * Extract pathname from a URL string, handling both absolute and relative URLs.
  */
@@ -141,9 +201,7 @@ async function extractBody(input, init) {
  */
 export function createFetchInterceptor(handle, options = {}) {
     const { baseUrl, passthrough = true, beforeRequest, beforeResponse, errorFormatter, } = options;
-    const originalFetch = globalThis.fetch;
-    let active = true;
-    globalThis.fetch = async (input, init) => {
+    return registerInterceptor(async (input, init) => {
         // Resolve the URL string
         const urlString = input instanceof Request
             ? input.url
@@ -162,13 +220,13 @@ export function createFetchInterceptor(handle, options = {}) {
             if (baseOrigin) {
                 const reqOrigin = extractOrigin(urlString);
                 if (reqOrigin !== baseOrigin) {
-                    return originalFetch(input, init);
+                    return PASSTHROUGH;
                 }
             }
             if (basePath) {
                 const isMatch = path === basePath || path.startsWith(`${basePath}/`);
                 if (!isMatch) {
-                    return originalFetch(input, init);
+                    return PASSTHROUGH;
                 }
             }
         }
@@ -200,7 +258,7 @@ export function createFetchInterceptor(handle, options = {}) {
             // Route not found — passthrough or 404
             if (isRouteNotFound(schmockResponse)) {
                 if (passthrough) {
-                    return originalFetch(input, init);
+                    return PASSTHROUGH;
                 }
                 return new Response(JSON.stringify({
                     error: "No matching mock route found",
@@ -223,13 +281,17 @@ export function createFetchInterceptor(handle, options = {}) {
             if (!responseHeaders.has("content-type") &&
                 response.body !== null &&
                 response.body !== undefined) {
-                responseHeaders.set("content-type", "application/json");
+                responseHeaders.set("content-type", isBinaryBody(response.body)
+                    ? "application/octet-stream"
+                    : "application/json");
             }
             const responseBody = response.body === null || response.body === undefined
                 ? null
                 : typeof response.body === "string"
                     ? response.body
-                    : JSON.stringify(response.body);
+                    : isBinaryBody(response.body)
+                        ? toFetchBinaryBody(response.body)
+                        : JSON.stringify(response.body);
             return new Response(responseBody, {
                 status: response.status,
                 headers: responseHeaders,
@@ -245,16 +307,5 @@ export function createFetchInterceptor(handle, options = {}) {
             }
             throw error;
         }
-    };
-    return {
-        restore() {
-            if (active) {
-                globalThis.fetch = originalFetch;
-                active = false;
-            }
-        },
-        get active() {
-            return active;
-        },
-    };
+    });
 }

package/dist/plugin-pipeline.d.ts

@@ -2,14 +2,21 @@
 interface PipelineLogger {
     log(category: string, message: string, data?: unknown): void;
 }
+interface PipelineResult {
+    context: Schmock.PluginContext;
+    response?: unknown;
+    recoveredFromError?: boolean;
+    requestShortCircuited?: boolean;
+}
+/** Run request guards before route code is allowed to execute. */
+export declare function runPluginBeforeRequest(plugins: Schmock.Plugin[], context: Schmock.PluginContext, logger: PipelineLogger): Promise<PipelineResult>;
+/** Give pipeline error handlers a chance to recover a route-generator error. */
+export declare function recoverGeneratorError(plugins: Schmock.Plugin[], context: Schmock.PluginContext, error: unknown, logger: PipelineLogger): Promise<PipelineResult>;
 /**
  * Run all registered plugins in sequence
  * First plugin to set response becomes generator, subsequent plugins transform
  * Handles plugin errors via onError hooks
  */
-export declare function runPluginPipeline(plugins: Schmock.Plugin[], context: Schmock.PluginContext, initialResponse: unknown, logger: PipelineLogger): Promise<{
-    context: Schmock.PluginContext;
-    response?: unknown;
-}>;
+export declare function runPluginPipeline(plugins: Schmock.Plugin[], context: Schmock.PluginContext, initialResponse: unknown, logger: PipelineLogger): Promise<PipelineResult>;
 export {};
 //# sourceMappingURL=plugin-pipeline.d.ts.map

package/dist/plugin-pipeline.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin-pipeline.d.ts","sourceRoot":"","sources":["../src/plugin-pipeline.ts"],"names":[],"mappings":"AAGA,uEAAuE;AACvE,UAAU,cAAc;IACtB,GAAG,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;CAC9D;AAED;;;;GAIG;AACH,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,OAAO,CAAC,MAAM,EAAE,EACzB,OAAO,EAAE,OAAO,CAAC,aAAa,EAC9B,eAAe,EAAE,OAAO,EACxB,MAAM,EAAE,cAAc,GACrB,OAAO,CAAC;IAAE,OAAO,EAAE,OAAO,CAAC,aAAa,CAAC;IAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC,CAoFjE"}
+{"version":3,"file":"plugin-pipeline.d.ts","sourceRoot":"","sources":["../src/plugin-pipeline.ts"],"names":[],"mappings":"AAEA,uEAAuE;AACvE,UAAU,cAAc;IACtB,GAAG,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;CAC9D;AAED,UAAU,cAAc;IACtB,OAAO,EAAE,OAAO,CAAC,aAAa,CAAC;IAC/B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,qBAAqB,CAAC,EAAE,OAAO,CAAC;CACjC;AAqDD,kEAAkE;AAClE,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,OAAO,CAAC,MAAM,EAAE,EACzB,OAAO,EAAE,OAAO,CAAC,aAAa,EAC9B,MAAM,EAAE,cAAc,GACrB,OAAO,CAAC,cAAc,CAAC,CAiDzB;AAED,gFAAgF;AAChF,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,OAAO,CAAC,MAAM,EAAE,EACzB,OAAO,EAAE,OAAO,CAAC,aAAa,EAC9B,KAAK,EAAE,OAAO,EACd,MAAM,EAAE,cAAc,GACrB,OAAO,CAAC,cAAc,CAAC,CAUzB;AAED;;;;GAIG;AACH,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,OAAO,CAAC,MAAM,EAAE,EACzB,OAAO,EAAE,OAAO,CAAC,aAAa,EAC9B,eAAe,EAAE,OAAO,EACxB,MAAM,EAAE,cAAc,GACrB,OAAO,CAAC,cAAc,CAAC,CA0DzB"}

package/dist/plugin-pipeline.js

@@ -1,5 +1,91 @@
-import { isStatusTuple } from "./constants.js";
 import { errorMessage, PluginError } from "./errors.js";
+function isPluginResult(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "context" in value &&
+        typeof value.context === "object" &&
+        value.context !== null);
+}
+async function recoverPluginError(plugins, startIndex, error, context, logger) {
+    let currentError = error instanceof Error ? error : new Error(errorMessage(error));
+    for (let index = startIndex; index < plugins.length; index += 1) {
+        const plugin = plugins[index];
+        if (!plugin.onError)
+            continue;
+        try {
+            const errorResult = await plugin.onError(currentError, context);
+            if (errorResult instanceof Error) {
+                currentError = errorResult;
+                continue;
+            }
+            if (errorResult !== undefined) {
+                logger.log("pipeline", `Plugin ${plugin.name} handled error`);
+                return { handled: true, response: errorResult };
+            }
+        }
+        catch (hookError) {
+            currentError =
+                hookError instanceof Error
+                    ? hookError
+                    : new Error(errorMessage(hookError));
+            logger.log("pipeline", `Plugin ${plugin.name} error handler failed: ${errorMessage(hookError)}`);
+        }
+    }
+    return { handled: false, error: currentError };
+}
+/** Run request guards before route code is allowed to execute. */
+export async function runPluginBeforeRequest(plugins, context, logger) {
+    let currentContext = context;
+    for (let index = 0; index < plugins.length; index += 1) {
+        const plugin = plugins[index];
+        if (!plugin.beforeRequest)
+            continue;
+        logger.log("pipeline", `Running beforeRequest: ${plugin.name}`);
+        try {
+            const result = await plugin.beforeRequest(currentContext);
+            if (result === undefined)
+                continue;
+            if (!isPluginResult(result)) {
+                throw new Error(`Plugin ${plugin.name} didn't return valid result`);
+            }
+            currentContext = result.context;
+            if (result.response !== undefined) {
+                logger.log("pipeline", `Plugin ${plugin.name} rejected request`);
+                return {
+                    context: currentContext,
+                    response: result.response,
+                    requestShortCircuited: true,
+                };
+            }
+        }
+        catch (error) {
+            logger.log("pipeline", `Plugin ${plugin.name} beforeRequest failed: ${errorMessage(error)}`);
+            const recovery = await recoverPluginError(plugins, index, error, currentContext, logger);
+            if (recovery.handled) {
+                return {
+                    context: currentContext,
+                    response: recovery.response,
+                    recoveredFromError: true,
+                    requestShortCircuited: true,
+                };
+            }
+            throw new PluginError(plugin.name, recovery.error);
+        }
+    }
+    return { context: currentContext };
+}
+/** Give pipeline error handlers a chance to recover a route-generator error. */
+export async function recoverGeneratorError(plugins, context, error, logger) {
+    const recovery = await recoverPluginError(plugins, 0, error, context, logger);
+    if (recovery.handled) {
+        return {
+            context,
+            response: recovery.response,
+            recoveredFromError: true,
+        };
+    }
+    throw recovery.error;
+}
 /**
  * Run all registered plugins in sequence
  * First plugin to set response becomes generator, subsequent plugins transform
@@ -9,11 +95,12 @@ export async function runPluginPipeline(plugins, context, initialResponse, logge
     let currentContext = context;
     let response = initialResponse;
     logger.log("pipeline", `Running plugin pipeline for ${plugins.length} plugins`);
-    for (const plugin of plugins) {
+    for (let index = 0; index < plugins.length; index += 1) {
+        const plugin = plugins[index];
         logger.log("pipeline", `Processing plugin: ${plugin.name}`);
         try {
             const result = await plugin.process(currentContext, response);
-            if (!result?.context) {
+            if (!isPluginResult(result)) {
                 throw new Error(`Plugin ${plugin.name} didn't return valid result`);
             }
             currentContext = result.context;
@@ -30,39 +117,15 @@ export async function runPluginPipeline(plugins, context, initialResponse, logge
         }
         catch (error) {
             logger.log("pipeline", `Plugin ${plugin.name} failed: ${errorMessage(error)}`);
-            // Try error handling if plugin has onError hook
-            if (plugin.onError) {
-                try {
-                    const pluginError = error instanceof Error ? error : new Error(errorMessage(error));
-                    const errorResult = await plugin.onError(pluginError, currentContext);
-                    if (errorResult) {
-                        logger.log("pipeline", `Plugin ${plugin.name} handled error`);
-                        // Error return → transform the thrown error
-                        if (errorResult instanceof Error) {
-                            throw new PluginError(plugin.name, errorResult);
-                        }
-                        // ResponseResult return → recover, stop pipeline
-                        // Accept both object-with-status and status tuple [code, body] / [code, body, headers]
-                        if (isStatusTuple(errorResult) ||
-                            (typeof errorResult === "object" &&
-                                errorResult !== null &&
-                                "status" in errorResult)) {
-                            response = errorResult;
-                            break;
-                        }
-                    }
-                    // void/falsy return → propagate original error below
-                }
-                catch (hookError) {
-                    // If the hook itself threw (including our PluginError above), re-throw it
-                    if (hookError instanceof PluginError) {
-                        throw hookError;
-                    }
-                    logger.log("pipeline", `Plugin ${plugin.name} error handler failed: ${errorMessage(hookError)}`);
-                }
+            const recovery = await recoverPluginError(plugins, index, error, currentContext, logger);
+            if (recovery.handled) {
+                return {
+                    context: currentContext,
+                    response: recovery.response,
+                    recoveredFromError: true,
+                };
             }
-            const cause = error instanceof Error ? error : new Error(errorMessage(error));
-            throw new PluginError(plugin.name, cause);
+            throw new PluginError(plugin.name, recovery.error);
         }
     }
     return { context: currentContext, response };

package/dist/response-parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"response-parser.d.ts","sourceRoot":"","sources":["../src/response-parser.ts"],"names":[],"mappings":"AAgBA;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,OAAO,EACf,WAAW,EAAE,OAAO,CAAC,WAAW,GAC/B,OAAO,CAAC,QAAQ,CAmDlB"}
+{"version":3,"file":"response-parser.d.ts","sourceRoot":"","sources":["../src/response-parser.ts"],"names":[],"mappings":"AAoCA;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,OAAO,EACf,WAAW,EAAE,OAAO,CAAC,WAAW,GAC/B,OAAO,CAAC,QAAQ,CAsElB"}

package/dist/response-parser.js

@@ -1,10 +1,23 @@
+import { isBinaryBody } from "./binary.js";
 import { isStatusTuple } from "./constants.js";
+const BINARY_CONTENT_TYPE = "application/octet-stream";
+function hasContentType(headers) {
+    return Object.keys(headers).some((header) => header.toLowerCase() === "content-type");
+}
 function isResponseObject(value) {
     return (typeof value === "object" &&
         value !== null &&
         "status" in value &&
         typeof value.status === "number" &&
-        "body" in value);
+        "body" in value &&
+        (!("headers" in value) ||
+            value.headers === undefined ||
+            isStringRecord(value.headers)));
+}
+function isStringRecord(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        Object.values(value).every((entry) => typeof entry === "string"));
 }
 /**
  * Parse and normalize response result into Response object
@@ -17,14 +30,13 @@ export function parseResponse(result, routeConfig) {
     let tupleFormat = false;
     // Handle already-formed response objects (from plugin error recovery)
     if (isResponseObject(result)) {
-        return {
-            status: result.status,
-            body: result.body,
-            headers: result.headers || {},
-        };
+        status = result.status;
+        body = result.body;
+        headers = result.headers ?? {};
+        tupleFormat = true;
     }
-    // Handle tuple response format [status, body, headers?]
-    if (isStatusTuple(result)) {
+    else if (isStatusTuple(result)) {
+        // Handle tuple response format [status, body, headers?]
         [status, body, headers = {}] = result;
         tupleFormat = true;
     }
@@ -36,18 +48,36 @@ export function parseResponse(result, routeConfig) {
         }
         body = undefined; // Ensure body is undefined for null responses
     }
+    const binaryBody = isBinaryBody(body);
+    // Binary response values need a transport-safe MIME type. Tuple headers still
+    // take precedence, while a non-JSON route override (for example image/png)
+    // remains authoritative for non-tuple responses.
+    if (!hasContentType(headers) && binaryBody) {
+        headers["content-type"] =
+            !tupleFormat &&
+                routeConfig.contentType &&
+                routeConfig.contentType !== "application/json"
+                ? routeConfig.contentType
+                : BINARY_CONTENT_TYPE;
+    }
     // Add content-type header from route config if it exists and headers don't already have it
     // But only if this isn't a tuple response (where headers are explicitly controlled)
-    if (!headers["content-type"] && routeConfig.contentType && !tupleFormat) {
+    let appliedRouteContentType = false;
+    if (!hasContentType(headers) && routeConfig.contentType && !tupleFormat) {
         headers["content-type"] = routeConfig.contentType;
-        // Handle special conversion cases when contentType is explicitly set
-        if (routeConfig.contentType === "text/plain" && body !== undefined) {
-            if (typeof body === "object" && !Buffer.isBuffer(body)) {
-                body = JSON.stringify(body);
-            }
-            else if (typeof body !== "string") {
-                body = String(body);
-            }
+        appliedRouteContentType = true;
+    }
+    // Handle special conversion cases when contentType is explicitly set. A
+    // binary body keeps its bytes even when a custom MIME type is configured.
+    if (appliedRouteContentType &&
+        routeConfig.contentType === "text/plain" &&
+        body !== undefined &&
+        !binaryBody) {
+        if (typeof body === "object") {
+            body = JSON.stringify(body);
+        }
+        else if (typeof body !== "string") {
+            body = String(body);
         }
     }
     return {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@schmock/core",
   "description": "Core functionality for Schmock",
-  "version": "2.2.2",
+  "version": "2.3.0",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -22,7 +22,7 @@
     "build:lib": "bun build --minify --target node --outdir=dist src/index.ts",
     "build:types": "rm -f tsconfig.tsbuildinfo && tsc --build && node scripts/embed-ambient-types.js",
     "pretest": "rm -f src/*.js src/*.d.ts || true",
-    "test": "vitest",
+    "test": "vitest run",
     "test:watch": "vitest --watch",
     "pretest:bdd": "rm -f src/*.js src/*.d.ts || true",
     "test:bdd": "vitest run --config vitest.config.bdd.ts",
@@ -31,9 +31,11 @@
     "check:publish": "publint && attw --pack --ignore-rules cjs-resolves-to-esm"
   },
   "license": "MIT",
+  "dependencies": {
+    "@types/json-schema": "^7.0.15"
+  },
   "devDependencies": {
     "@amiceli/vitest-cucumber": "^7.0.0",
-    "@types/json-schema": "^7.0.15",
     "@types/node": "^26.1.0",
     "@vitest/ui": "^4.1.9",
     "vitest": "^4.1.9"

package/src/binary.test.ts

@@ -0,0 +1,126 @@
+import { describe, expect, it } from "vitest";
+import { isBinaryBody } from "./binary.js";
+import { schmock } from "./index.js";
+import { parseResponse } from "./response-parser.js";
+
+function binaryBytes(value: unknown): number[] {
+  if (value instanceof ArrayBuffer) {
+    return [...new Uint8Array(value)];
+  }
+  if (ArrayBuffer.isView(value)) {
+    return [
+      ...new Uint8Array(value.buffer, value.byteOffset, value.byteLength),
+    ];
+  }
+  throw new Error("Expected a binary response body");
+}
+
+describe("isBinaryBody", () => {
+  it("recognizes browser binary values without a Node Buffer global", () => {
+    expect(isBinaryBody(new Uint8Array([1, 2, 3]))).toBe(true);
+    expect(isBinaryBody(new ArrayBuffer(3))).toBe(true);
+    expect(isBinaryBody(new DataView(new SharedArrayBuffer(3)))).toBe(true);
+    expect(isBinaryBody({ 0: 1, length: 1 })).toBe(false);
+  });
+});
+
+describe("parseResponse binary handling", () => {
+  it("stringifies text objects when Buffer is not available", () => {
+    const originalBuffer = globalThis.Buffer;
+    Reflect.deleteProperty(globalThis, "Buffer");
+
+    try {
+      const response = parseResponse(
+        { message: "browser" },
+        { contentType: "text/plain" },
+      );
+
+      expect(response.body).toBe('{"message":"browser"}');
+    } finally {
+      globalThis.Buffer = originalBuffer;
+    }
+  });
+
+  it("detects binary returned by a dynamic generator", async () => {
+    const mock = schmock();
+    mock("GET /dynamic-binary", () => new Uint8Array([1, 2, 3]));
+
+    const response = await mock.handle("GET", "/dynamic-binary");
+
+    expect(response.headers["content-type"]).toBe("application/octet-stream");
+    expect(binaryBytes(response.body)).toEqual([1, 2, 3]);
+  });
+
+  it("detects binary in a status tuple", async () => {
+    const mock = schmock();
+    const bytes = new Uint8Array([4, 5, 6]);
+    mock(
+      "GET /tuple-binary",
+      () => [206, new DataView(bytes.buffer)] satisfies [number, unknown],
+    );
+
+    const response = await mock.handle("GET", "/tuple-binary");
+
+    expect(response.status).toBe(206);
+    expect(response.headers["content-type"]).toBe("application/octet-stream");
+    expect(binaryBytes(response.body)).toEqual([4, 5, 6]);
+  });
+
+  it("detects binary in a response object", () => {
+    const response = parseResponse(
+      { status: 206, body: new Uint8Array([7, 8]), headers: {} },
+      {},
+    );
+
+    expect(response.status).toBe(206);
+    expect(response.headers["content-type"]).toBe("application/octet-stream");
+    expect(binaryBytes(response.body)).toEqual([7, 8]);
+  });
+
+  it("preserves an explicit binary content type", async () => {
+    const mock = schmock();
+    mock("GET /image", () => new Uint8Array([137, 80, 78, 71]), {
+      contentType: "image/png",
+    });
+
+    const response = await mock.handle("GET", "/image");
+
+    expect(response.headers["content-type"]).toBe("image/png");
+    expect(binaryBytes(response.body)).toEqual([137, 80, 78, 71]);
+  });
+
+  it("preserves a tuple content-type header without adding a duplicate", () => {
+    const response = parseResponse(
+      [
+        200,
+        new Uint8Array([1]),
+        { "Content-Type": "application/custom-binary" },
+      ],
+      { contentType: "application/json" },
+    );
+
+    expect(response.headers).toEqual({
+      "Content-Type": "application/custom-binary",
+    });
+    expect(binaryBytes(response.body)).toEqual([1]);
+  });
+});
+
+describe("browser runtime compatibility", () => {
+  it("defines and serves object routes when Buffer is not available", async () => {
+    const originalBuffer = globalThis.Buffer;
+    Reflect.deleteProperty(globalThis, "Buffer");
+
+    try {
+      const mock = schmock();
+      mock("GET /browser", { runtime: "browser" });
+
+      const response = await mock.handle("GET", "/browser");
+      expect(response.status).toBe(200);
+      expect(response.body).toEqual({ runtime: "browser" });
+      expect(response.headers["content-type"]).toBe("application/json");
+    } finally {
+      globalThis.Buffer = originalBuffer;
+    }
+  });
+});

package/src/binary.ts

@@ -0,0 +1,11 @@
+/**
+ * Browser-safe binary body detection.
+ *
+ * Every ArrayBuffer view is accepted, including DataView, typed arrays backed
+ * by SharedArrayBuffer, and Node.js Buffer without referencing its global.
+ */
+export function isBinaryBody(
+  value: unknown,
+): value is ArrayBuffer | ArrayBufferView {
+  return value instanceof ArrayBuffer || ArrayBuffer.isView(value);
+}