@zimic/interceptor 1.2.7-canary.2 → 1.3.0-canary.0

package/dist/server.js

@@ -1,29 +1,29 @@
 'use strict';
 
-var chunkPB4TJVK3_js = require('./chunk-PB4TJVK3.js');
+var chunkKDM6Y6GO_js = require('./chunk-KDM6Y6GO.js');
 require('./chunk-DGUM43GV.js');
 
 
 
 Object.defineProperty(exports, "DEFAULT_ACCESS_CONTROL_HEADERS", {
   enumerable: true,
-  get: function () { return chunkPB4TJVK3_js.DEFAULT_ACCESS_CONTROL_HEADERS; }
+  get: function () { return chunkKDM6Y6GO_js.DEFAULT_ACCESS_CONTROL_HEADERS; }
 });
 Object.defineProperty(exports, "DEFAULT_PREFLIGHT_STATUS_CODE", {
   enumerable: true,
-  get: function () { return chunkPB4TJVK3_js.DEFAULT_PREFLIGHT_STATUS_CODE; }
+  get: function () { return chunkKDM6Y6GO_js.DEFAULT_PREFLIGHT_STATUS_CODE; }
 });
 Object.defineProperty(exports, "NotRunningInterceptorServerError", {
   enumerable: true,
-  get: function () { return chunkPB4TJVK3_js.NotRunningInterceptorServerError_default; }
+  get: function () { return chunkKDM6Y6GO_js.NotRunningInterceptorServerError_default; }
 });
 Object.defineProperty(exports, "RunningInterceptorServerError", {
   enumerable: true,
-  get: function () { return chunkPB4TJVK3_js.RunningInterceptorServerError_default; }
+  get: function () { return chunkKDM6Y6GO_js.RunningInterceptorServerError_default; }
 });
 Object.defineProperty(exports, "createInterceptorServer", {
   enumerable: true,
-  get: function () { return chunkPB4TJVK3_js.createInterceptorServer; }
+  get: function () { return chunkKDM6Y6GO_js.createInterceptorServer; }
 });
 //# sourceMappingURL=server.js.map
 //# sourceMappingURL=server.js.map

package/dist/server.mjs

@@ -1,4 +1,4 @@
-export { DEFAULT_ACCESS_CONTROL_HEADERS, DEFAULT_PREFLIGHT_STATUS_CODE, NotRunningInterceptorServerError_default as NotRunningInterceptorServerError, RunningInterceptorServerError_default as RunningInterceptorServerError, createInterceptorServer } from './chunk-6GEP6R3L.mjs';
+export { DEFAULT_ACCESS_CONTROL_HEADERS, DEFAULT_PREFLIGHT_STATUS_CODE, NotRunningInterceptorServerError_default as NotRunningInterceptorServerError, RunningInterceptorServerError_default as RunningInterceptorServerError, createInterceptorServer } from './chunk-5CI37HTA.mjs';
 import './chunk-BJTO5JO5.mjs';
 //# sourceMappingURL=server.mjs.map
 //# sourceMappingURL=server.mjs.map

package/package.json

@@ -14,7 +14,7 @@
     "api",
     "static"
   ],
-  "version": "1.2.7-canary.2",
+  "version": "1.3.0-canary.0",
   "homepage": "https://zimic.dev/docs/interceptor",
   "repository": {
     "type": "git",
@@ -90,7 +90,7 @@
     "style:check": "pnpm style --check",
     "style:format": "pnpm style --write",
     "test": "dotenv -v NODE_ENV=test -v FORCE_COLOR=1 -- vitest",
-    "test:turbo": "dotenv -v CI=true -- pnpm run test run --coverage",
+    "test:turbo": "dotenv -v CI=true -- pnpm run test --coverage --reporter tree",
     "types:check": "tsc --noEmit",
     "postinstall": "node --enable-source-maps -e \"try{require('./dist/scripts/postinstall')}catch(error){console.error(error)}\""
   },

package/src/http/interceptor/HttpInterceptorClient.ts

@@ -267,7 +267,7 @@ class HttpInterceptorClient<
     }
   }
 
-  private async handleInterceptedRequest<
+  async handleInterceptedRequest<
     Method extends HttpSchemaMethod<Schema>,
     Path extends HttpSchemaPath<Schema, Method>,
     Context extends HttpInterceptorRequestContext<Schema, Method, Path>,
@@ -289,15 +289,15 @@ class HttpInterceptorClient<
       return null;
     }
 
-    const response = HttpInterceptorWorker.createResponseFromDeclaration(request, responseDeclaration);
+    const response = await this.workerOrThrow.createResponseFromDeclaration(request, responseDeclaration);
 
-    if (this.requestSaving.enabled) {
+    const shouldSaveInterceptedRequest =
+      this.requestSaving.enabled && response && !HttpInterceptorWorker.isRejectedResponse(response);
+
+    if (shouldSaveInterceptedRequest) {
       const responseClone = response.clone();
 
-      const parsedResponse = await HttpInterceptorWorker.parseRawResponse<
-        Default<Schema[Path][Method]>,
-        typeof responseDeclaration.status
-      >(responseClone);
+      const parsedResponse = await HttpInterceptorWorker.parseRawResponse<Default<Schema[Path][Method]>>(responseClone);
 
       matchedHandler.saveInterceptedRequest(parsedRequest, parsedResponse);
     }

package/src/http/interceptor/types/options.ts

@@ -12,7 +12,13 @@ export type HttpInterceptorPlatform = 'node' | 'browser';
 /** @see {@link https://zimic.dev/docs/interceptor/guides/http/unhandled-requests Unhandled requests} */
 export namespace UnhandledRequestStrategy {
   /** @see {@link https://zimic.dev/docs/interceptor/guides/http/unhandled-requests Unhandled requests} */
-  export type Action = 'bypass' | 'reject';
+  export type LocalAction = 'bypass' | 'reject';
+
+  /** @see {@link https://zimic.dev/docs/interceptor/guides/http/unhandled-requests Unhandled requests} */
+  export type RemoteAction = 'reject';
+
+  /** @see {@link https://zimic.dev/docs/interceptor/guides/http/unhandled-requests Unhandled requests} */
+  export type Action = LocalAction | RemoteAction;
 
   /** @see {@link https://zimic.dev/docs/interceptor/guides/http/unhandled-requests Unhandled requests} */
   export interface Declaration<DeclarationAction extends Action = Action> {
@@ -29,16 +35,16 @@ export namespace UnhandledRequestStrategy {
   ) => PossiblePromise<Declaration<DeclarationAction>>;
 
   /** @see {@link https://zimic.dev/docs/interceptor/guides/http/unhandled-requests Unhandled requests} */
-  export type LocalDeclaration = Declaration;
+  export type LocalDeclaration = Declaration<LocalAction>;
 
   /** @see {@link https://zimic.dev/docs/interceptor/guides/http/unhandled-requests Unhandled requests} */
-  export type LocalDeclarationFactory = DeclarationFactory;
+  export type LocalDeclarationFactory = DeclarationFactory<LocalAction>;
 
   /** @see {@link https://zimic.dev/docs/interceptor/guides/http/unhandled-requests Unhandled requests} */
-  export type RemoteDeclaration = Declaration<'reject'>;
+  export type RemoteDeclaration = Declaration<RemoteAction>;
 
   /** @see {@link https://zimic.dev/docs/interceptor/guides/http/unhandled-requests Unhandled requests} */
-  export type RemoteDeclarationFactory = DeclarationFactory<'reject'>;
+  export type RemoteDeclarationFactory = DeclarationFactory<RemoteAction>;
 
   /** @see {@link https://zimic.dev/docs/interceptor/guides/http/unhandled-requests Unhandled requests} */
   export type Local = LocalDeclaration | LocalDeclarationFactory;

package/src/http/interceptorWorker/HttpInterceptorWorker.ts

@@ -10,6 +10,7 @@ import {
   InferPathParams,
   parseHttpBody,
   HttpSearchParams,
+  HttpRequest,
 } from '@zimic/http';
 import isDefined from '@zimic/utils/data/isDefined';
 import { Default, PossiblePromise } from '@zimic/utils/types';
@@ -33,9 +34,11 @@ import {
   HttpInterceptorResponse,
 } from '../requestHandler/types/requests';
 import { DEFAULT_UNHANDLED_REQUEST_STRATEGY } from './constants';
-import { MSWHttpResponseFactory } from './types/msw';
+import { HttpResponseFactory } from './types/http';
 import { HttpInterceptorWorkerType } from './types/options';
 
+const RESPONSE_ACTION_SYMBOL = Symbol.for('HttpResponse.action');
+
 abstract class HttpInterceptorWorker {
   abstract get type(): HttpInterceptorWorkerType;
 
@@ -100,7 +103,7 @@ abstract class HttpInterceptorWorker {
     interceptor: HttpInterceptorClient<Schema>,
     method: HttpMethod,
     path: string,
-    createResponse: MSWHttpResponseFactory,
+    createResponse: HttpResponseFactory,
   ): PossiblePromise<void>;
 
   protected async logUnhandledRequestIfNecessary(
@@ -189,17 +192,71 @@ abstract class HttpInterceptorWorker {
 
   abstract get interceptorsWithHandlers(): AnyHttpInterceptorClient[];
 
-  static createResponseFromDeclaration(
-    request: Request,
-    declaration: { status: number; headers?: HttpHeadersInit; body?: HttpBody },
-  ): HttpResponse {
+  static setResponseAction(response: Response, action: UnhandledRequestStrategy.Action) {
+    Object.defineProperty(response, RESPONSE_ACTION_SYMBOL, {
+      value: action,
+      enumerable: false,
+      configurable: false,
+      writable: false,
+    });
+  }
+
+  static getResponseAction(response: Response): UnhandledRequestStrategy.Action | undefined {
+    if (!(RESPONSE_ACTION_SYMBOL in response)) {
+      return undefined;
+    }
+
+    const action = response[RESPONSE_ACTION_SYMBOL];
+
+    /* istanbul ignore if -- @preserve
+     * This is just a type guard to ensure the value is valid. In practice, this condition should never be true. */
+    if (action !== 'bypass' && action !== 'reject') {
+      return undefined;
+    }
+
+    return action;
+  }
+
+  private createBypassedResponse() {
+    const response = Response.redirect('about:blank', 302) as HttpResponse;
+    HttpInterceptorWorker.setResponseAction(response, 'bypass');
+    return response;
+  }
+
+  static isBypassedResponse(response: Response) {
+    return this.getResponseAction(response) === 'bypass';
+  }
+
+  private createRejectedResponse() {
+    const response = Response.error() as HttpResponse;
+    HttpInterceptorWorker.setResponseAction(response, 'reject');
+    return response;
+  }
+
+  static isRejectedResponse(response: Response) {
+    return this.getResponseAction(response) === 'reject';
+  }
+
+  createResponseFromDeclaration(
+    request: HttpRequest,
+    declaration:
+      | { status: number; headers?: HttpHeadersInit; body?: HttpBody }
+      | { action: UnhandledRequestStrategy.Action },
+  ): PossiblePromise<HttpResponse | null> {
+    if ('action' in declaration) {
+      if (declaration.action === 'bypass') {
+        return this.createBypassedResponse();
+      } else {
+        return this.createRejectedResponse();
+      }
+    }
+
     const headers = new HttpHeaders(declaration.headers);
-    const status = declaration.status;
 
-    const canHaveBody = methodCanHaveResponseBody(request.method as HttpMethod) && status !== 204;
+    const canHaveBody = methodCanHaveResponseBody(request.method as HttpMethod) && declaration.status !== 204;
 
     if (!canHaveBody) {
-      return new Response(null, { headers, status }) as HttpResponse;
+      return new Response(null, { headers, status: declaration.status }) as HttpResponse;
     }
 
     if (
@@ -212,10 +269,10 @@ abstract class HttpInterceptorWorker {
       declaration.body instanceof ArrayBuffer ||
       declaration.body instanceof ReadableStream
     ) {
-      return new Response(declaration.body ?? null, { headers, status }) as HttpResponse;
+      return new Response(declaration.body ?? null, { headers, status: declaration.status }) as HttpResponse;
     }
 
-    return Response.json(declaration.body, { headers, status }) as HttpResponse;
+    return Response.json(declaration.body, { headers, status: declaration.status }) as HttpResponse;
   }
 
   static async parseRawUnhandledRequest(request: Request) {
@@ -305,9 +362,10 @@ abstract class HttpInterceptorWorker {
     return HTTP_INTERCEPTOR_REQUEST_HIDDEN_PROPERTIES.has(property as never);
   }
 
-  static async parseRawResponse<MethodSchema extends HttpMethodSchema, StatusCode extends HttpStatusCode>(
-    originalRawResponse: Response,
-  ): Promise<HttpInterceptorResponse<MethodSchema, StatusCode>> {
+  static async parseRawResponse<
+    MethodSchema extends HttpMethodSchema,
+    StatusCode extends HttpStatusCode = HttpStatusCode,
+  >(originalRawResponse: Response): Promise<HttpInterceptorResponse<MethodSchema, StatusCode>> {
     const rawResponse = originalRawResponse.clone();
     const rawResponseClone = rawResponse.clone();
 

package/src/http/interceptorWorker/LocalHttpInterceptorWorker.ts

@@ -1,8 +1,8 @@
-import { HttpRequest, HttpResponse, HttpMethod, HttpSchema } from '@zimic/http';
+import { HttpRequest, HttpResponse, HttpMethod, HttpSchema, HttpHeadersInit, HttpBody } from '@zimic/http';
 import createRegexFromPath from '@zimic/utils/url/createRegexFromPath';
 import excludeNonPathParams from '@zimic/utils/url/excludeNonPathParams';
 import validatePathParams from '@zimic/utils/url/validatePathParams';
-import { SharedOptions as MSWWorkerSharedOptions, http, passthrough } from 'msw';
+import { SharedOptions as MSWWorkerSharedOptions, bypass, http, passthrough } from 'msw';
 import * as mswBrowser from 'msw/browser';
 import * as mswNode from 'msw/node';
 
@@ -12,10 +12,11 @@ import { isClientSide, isServerSide } from '@/utils/environment';
 import NotRunningHttpInterceptorError from '../interceptor/errors/NotRunningHttpInterceptorError';
 import UnknownHttpInterceptorPlatformError from '../interceptor/errors/UnknownHttpInterceptorPlatformError';
 import HttpInterceptorClient, { AnyHttpInterceptorClient } from '../interceptor/HttpInterceptorClient';
+import { UnhandledRequestStrategy } from '../interceptor/types/options';
 import UnregisteredBrowserServiceWorkerError from './errors/UnregisteredBrowserServiceWorkerError';
 import HttpInterceptorWorker from './HttpInterceptorWorker';
-import { HttpResponseFactoryContext } from './types/http';
-import { BrowserMSWWorker, MSWHttpResponseFactory, MSWWorker, NodeMSWWorker } from './types/msw';
+import { HttpResponseFactory, HttpResponseFactoryContext } from './types/http';
+import { BrowserMSWWorker, MSWWorker, NodeMSWWorker } from './types/msw';
 import { LocalHttpInterceptorWorkerOptions } from './types/options';
 
 interface HttpHandler {
@@ -163,7 +164,7 @@ class LocalHttpInterceptorWorker extends HttpInterceptorWorker {
     interceptor: HttpInterceptorClient<Schema>,
     method: HttpMethod,
     path: string,
-    createResponse: MSWHttpResponseFactory,
+    createResponse: HttpResponseFactory,
   ) {
     if (!this.isRunning) {
       throw new NotRunningHttpInterceptorError();
@@ -185,7 +186,7 @@ class LocalHttpInterceptorWorker extends HttpInterceptorWorker {
         let response: HttpResponse | null = null;
 
         try {
-          response = await createResponse({ ...context, request });
+          response = await createResponse({ request });
         } catch (error) {
           console.error(error);
         }
@@ -209,6 +210,32 @@ class LocalHttpInterceptorWorker extends HttpInterceptorWorker {
     methodHandlers.push(handler);
   }
 
+  async createResponseFromDeclaration(
+    request: HttpRequest,
+    declaration:
+      | { status: number; headers?: HttpHeadersInit; body?: HttpBody }
+      | { action: UnhandledRequestStrategy.Action },
+  ) {
+    const requestClone = request.clone();
+    const response = await super.createResponseFromDeclaration(request, declaration);
+
+    if (response && HttpInterceptorWorker.isBypassedResponse(response)) {
+      try {
+        const response = (await fetch(bypass(requestClone))) as HttpResponse;
+        return response;
+      } catch (error) {
+        console.error(error);
+        return null;
+      }
+    }
+
+    if (response && HttpInterceptorWorker.isRejectedResponse(response)) {
+      return response;
+    }
+
+    return response;
+  }
+
   private async createResponseForRequest(request: HttpRequest) {
     const methodHandlers = this.httpHandlersByMethod[request.method as HttpMethod];
 
@@ -244,9 +271,9 @@ class LocalHttpInterceptorWorker extends HttpInterceptorWorker {
     await super.logUnhandledRequestIfNecessary(requestClone, strategy);
 
     if (strategy?.action === 'reject') {
-      return Response.error();
+      return Response.error() as HttpResponse;
     } else {
-      return passthrough();
+      return passthrough() as HttpResponse;
     }
   }
 

package/src/http/interceptorWorker/RemoteHttpInterceptorWorker.ts

@@ -1,10 +1,13 @@
-import { HttpMethod, HttpSchema } from '@zimic/http';
+import { HttpBody, HttpHeadersInit, HttpMethod, HttpRequest, HttpSchema } from '@zimic/http';
+import { PossiblePromise } from '@zimic/utils/types';
 import validatePathParams from '@zimic/utils/url/validatePathParams';
 
+import UnsupportedResponseBypassError from '@/server/errors/UnsupportedResponseBypassError';
 import { HttpHandlerCommit, InterceptorServerWebSocketSchema } from '@/server/types/schema';
 import { importCrypto } from '@/utils/crypto';
 import { isClientSide, isServerSide } from '@/utils/environment';
 import { deserializeRequest, serializeResponse } from '@/utils/fetch';
+import { methodCanHaveResponseBody } from '@/utils/http';
 import { WebSocketMessageAbortError } from '@/utils/webSocket';
 import { WebSocketEventMessage } from '@/webSocket/types';
 import WebSocketClient from '@/webSocket/WebSocketClient';
@@ -12,10 +15,9 @@ import WebSocketClient from '@/webSocket/WebSocketClient';
 import NotRunningHttpInterceptorError from '../interceptor/errors/NotRunningHttpInterceptorError';
 import UnknownHttpInterceptorPlatformError from '../interceptor/errors/UnknownHttpInterceptorPlatformError';
 import HttpInterceptorClient, { AnyHttpInterceptorClient } from '../interceptor/HttpInterceptorClient';
-import { HttpInterceptorPlatform } from '../interceptor/types/options';
+import { HttpInterceptorPlatform, UnhandledRequestStrategy } from '../interceptor/types/options';
 import HttpInterceptorWorker from './HttpInterceptorWorker';
-import { HttpResponseFactoryContext } from './types/http';
-import { MSWHttpResponseFactory } from './types/msw';
+import { HttpResponseFactory, HttpResponseFactoryContext } from './types/http';
 import { RemoteHttpInterceptorWorkerOptions } from './types/options';
 
 interface HttpHandler {
@@ -24,7 +26,7 @@ interface HttpHandler {
   method: HttpMethod;
   path: string;
   interceptor: AnyHttpInterceptorClient;
-  createResponse: (context: HttpResponseFactoryContext) => Promise<Response | null>;
+  createResponse: (context: HttpResponseFactoryContext) => PossiblePromise<Response | null>;
 }
 
 class RemoteHttpInterceptorWorker extends HttpInterceptorWorker {
@@ -78,9 +80,12 @@ class RemoteHttpInterceptorWorker extends HttpInterceptorWorker {
 
     try {
       const rawResponse = (await handler?.createResponse({ request })) ?? null;
-      const response = rawResponse && request.method === 'HEAD' ? new Response(null, rawResponse) : rawResponse;
 
-      if (response) {
+      if (rawResponse) {
+        const response = methodCanHaveResponseBody(request.method as HttpMethod)
+          ? rawResponse
+          : new Response(null, rawResponse);
+
         return { response: await serializeResponse(response) };
       }
     } catch (error) {
@@ -135,7 +140,7 @@ class RemoteHttpInterceptorWorker extends HttpInterceptorWorker {
     interceptor: HttpInterceptorClient<Schema>,
     method: HttpMethod,
     path: string,
-    createResponse: MSWHttpResponseFactory,
+    createResponse: HttpResponseFactory,
   ) {
     if (!this.isRunning) {
       throw new NotRunningHttpInterceptorError();
@@ -151,10 +156,7 @@ class RemoteHttpInterceptorWorker extends HttpInterceptorWorker {
       method,
       path,
       interceptor,
-      async createResponse(context) {
-        const response = await createResponse(context);
-        return response;
-      },
+      createResponse,
     };
 
     this.httpHandlers.set(handler.id, handler);
@@ -167,6 +169,25 @@ class RemoteHttpInterceptorWorker extends HttpInterceptorWorker {
     });
   }
 
+  async createResponseFromDeclaration(
+    request: HttpRequest,
+    declaration:
+      | { status: number; headers?: HttpHeadersInit; body?: HttpBody }
+      | { action: UnhandledRequestStrategy.Action },
+  ) {
+    const response = await super.createResponseFromDeclaration(request, declaration);
+
+    if (response && HttpInterceptorWorker.isBypassedResponse(response)) {
+      throw new UnsupportedResponseBypassError();
+    }
+
+    if (response && HttpInterceptorWorker.isRejectedResponse(response)) {
+      return response;
+    }
+
+    return response;
+  }
+
   async clearHandlers<Schema extends HttpSchema>(
     options: {
       interceptor?: HttpInterceptorClient<Schema>;

package/src/http/interceptorWorker/types/http.ts

@@ -1,5 +1,10 @@
-import { HttpBody, HttpRequest } from '@zimic/http';
+import { HttpBody, HttpRequest, HttpResponse } from '@zimic/http';
+import { PossiblePromise } from '@zimic/utils/types';
 
 export interface HttpResponseFactoryContext<Body extends HttpBody = HttpBody> {
   request: HttpRequest<Body>;
 }
+
+export type HttpResponseFactory<RequestBody extends HttpBody = HttpBody, ResponseBody extends HttpBody = HttpBody> = (
+  context: HttpResponseFactoryContext<RequestBody>,
+) => PossiblePromise<HttpResponse<ResponseBody> | null>;

package/src/http/interceptorWorker/types/msw.ts

@@ -1,16 +1,7 @@
-import { HttpResponse, HttpBody } from '@zimic/http';
-import { PossiblePromise } from '@zimic/utils/types';
 import type { HttpHandler as MSWHandler } from 'msw';
 import type { SetupWorker as BrowserMSWWorker } from 'msw/browser';
 import type { SetupServer as NodeMSWWorker } from 'msw/node';
 
-import { HttpResponseFactoryContext } from './http';
-
 export type { MSWHandler, NodeMSWWorker, BrowserMSWWorker };
 
 export type MSWWorker = NodeMSWWorker | BrowserMSWWorker;
-
-export type MSWHttpResponseFactory<
-  RequestBody extends HttpBody = HttpBody,
-  ResponseBody extends HttpBody = HttpBody,
-> = (context: HttpResponseFactoryContext<RequestBody>) => PossiblePromise<HttpResponse<ResponseBody> | null>;

package/src/http/requestHandler/types/requests.ts

@@ -16,6 +16,8 @@ import {
 } from '@zimic/http';
 import { Default, PartialByKey, PossiblePromise, Replace } from '@zimic/utils/types';
 
+import { UnhandledRequestStrategy } from '@/http/interceptor/types/options';
+
 type HttpRequestHandlerResponseBody<
   ResponseSchema extends HttpResponseSchema,
   StatusCode extends HttpStatusCode,
@@ -42,17 +44,29 @@ export type HttpRequestHandlerResponseDeclarationWithHeaders<ResponseSchema exte
       : { headers: HttpRequestHandlerResponseDeclarationHeaders<ResponseSchema> };
 
 /** @see {@link https://zimic.dev/docs/interceptor/api/http-request-handler#handlerrespond `handler.respond()` API reference} */
-export type HttpRequestHandlerResponseDeclaration<
+export type HttpRequestHandlerStatusResponseDeclaration<
   MethodSchema extends HttpMethodSchema = HttpMethodSchema,
   StatusCode extends HttpStatusCode = HttpStatusCode,
 > = StatusCode extends StatusCode
-  ? { status: StatusCode } & HttpRequestHandlerResponseWithBody<
+  ? { status: StatusCode; action?: never } & HttpRequestHandlerResponseWithBody<
       Default<Default<MethodSchema['response']>[StatusCode]>,
       StatusCode
     > &
       HttpRequestHandlerResponseDeclarationWithHeaders<Default<Default<MethodSchema['response']>[StatusCode]>>
   : never;
 
+/** @see {@link https://zimic.dev/docs/interceptor/api/http-request-handler#handlerrespond `handler.respond()` API reference} */
+export interface HttpRequestHandlerActionResponseDeclaration {
+  status?: never;
+  action: UnhandledRequestStrategy.Action;
+}
+
+/** @see {@link https://zimic.dev/docs/interceptor/api/http-request-handler#handlerrespond `handler.respond()` API reference} */
+export type HttpRequestHandlerResponseDeclaration<
+  MethodSchema extends HttpMethodSchema = HttpMethodSchema,
+  StatusCode extends HttpStatusCode = HttpStatusCode,
+> = HttpRequestHandlerStatusResponseDeclaration<MethodSchema, StatusCode> | HttpRequestHandlerActionResponseDeclaration;
+
 /** @see {@link https://zimic.dev/docs/interceptor/api/http-request-handler#handlerrespond `handler.respond()` API reference} */
 export type HttpRequestHandlerResponseDeclarationFactory<
   Path extends string,

package/src/server/InterceptorServer.ts

@@ -297,8 +297,17 @@ class InterceptorServer implements PublicInterceptorServer {
       const { response, matchedSomeInterceptor } = await this.createResponseForRequest(serializedRequest);
 
       if (response) {
-        this.setDefaultAccessControlHeaders(response, ['access-control-allow-origin', 'access-control-expose-headers']);
-        await sendNodeResponse(response, nodeResponse, nodeRequest, true);
+        if (HttpInterceptorWorker.isRejectedResponse(response)) {
+          nodeResponse.destroy();
+        } else {
+          this.setDefaultAccessControlHeaders(response, [
+            'access-control-allow-origin',
+            'access-control-expose-headers',
+          ]);
+
+          await sendNodeResponse(response, nodeResponse, nodeRequest, true);
+        }
+
         return;
       }
 

package/src/server/errors/UnsupportedResponseBypassError.ts

@@ -0,0 +1,11 @@
+class UnsupportedResponseBypassError extends Error {
+  constructor() {
+    super(
+      "Remote interceptors cannot bypass responses. Use `{ action: 'reject' }` instead.\n\n" +
+        'Learn more: https://zimic.dev/docs/interceptor/api/http-request-handler#handlerrespond',
+    );
+    this.name = 'UnsupportedResponseBypassError';
+  }
+}
+
+export default UnsupportedResponseBypassError;

package/src/utils/fetch.ts

@@ -1,5 +1,8 @@
 import { JSONValue } from '@zimic/http';
 
+import { UnhandledRequestStrategy } from '@/http';
+import HttpInterceptorWorker from '@/http/interceptorWorker/HttpInterceptorWorker';
+
 import { convertArrayBufferToBase64, convertBase64ToArrayBuffer } from './data';
 
 export type SerializedHttpRequest = JSONValue<{
@@ -56,6 +59,8 @@ export function deserializeRequest(serializedRequest: SerializedHttpRequest): Re
 }
 
 export type SerializedResponse = JSONValue<{
+  type: Response['type'];
+  action?: UnhandledRequestStrategy.Action;
   status: number;
   statusText: string;
   headers: Record<string, string>;
@@ -67,6 +72,8 @@ export async function serializeResponse(response: Response): Promise<SerializedR
   const serializedBody = responseClone.body ? convertArrayBufferToBase64(await responseClone.arrayBuffer()) : null;
 
   return {
+    type: response.type,
+    action: HttpInterceptorWorker.getResponseAction(response),
     status: response.status,
     statusText: response.statusText,
     headers: Object.fromEntries(response.headers),
@@ -75,11 +82,23 @@ export async function serializeResponse(response: Response): Promise<SerializedR
 }
 
 export function deserializeResponse(serializedResponse: SerializedResponse): Response {
-  const deserializedBody = serializedResponse.body ? convertBase64ToArrayBuffer(serializedResponse.body) : null;
+  let response: Response;
 
-  return new Response(deserializedBody, {
-    status: serializedResponse.status,
-    statusText: serializedResponse.statusText,
-    headers: new Headers(serializedResponse.headers),
-  });
+  if (serializedResponse.type === 'error') {
+    response = Response.error();
+  } else {
+    const deserializedBody = serializedResponse.body ? convertBase64ToArrayBuffer(serializedResponse.body) : null;
+
+    response = new Response(deserializedBody, {
+      status: serializedResponse.status,
+      statusText: serializedResponse.statusText,
+      headers: new Headers(serializedResponse.headers),
+    });
+  }
+
+  if (serializedResponse.action) {
+    HttpInterceptorWorker.setResponseAction(response, serializedResponse.action);
+  }
+
+  return response;
 }