fx-fetch 1.1.1 → 1.1.2

package/dist/Fetch/Fetch.d.ts

@@ -2,21 +2,36 @@ import { type Effect } from 'effect/Effect';
 import type { Request } from "../Request/index.js";
 import { NotOkError, type Response } from "../Response/index.js";
 import { AbortError, FetchError, NotAllowedError } from "./errors.js";
-declare const Fetch_base: import("effect/Context").TagClass<Fetch, "fx-fetch/Fetch", (request: Request) => Effect<Response, AbortError | FetchError | NotAllowedError | NotOkError, never>>;
+export declare namespace Fetch {
+    /**
+     * Type alias for the successful response type of the Fetch service.
+     * @since 1.2.0
+     * @category Models
+     */
+    type SuccessType = Response;
+    /**
+     * Type alias for the failure response type of the Fetch service.
+     * @since 1.2.0
+     * @category Models
+     */
+    type ErrorType = AbortError | FetchError | NotAllowedError | NotOkError;
+}
+declare const Fetch_base: import("effect/Context").TagClass<Fetch, "fx-fetch/Fetch", (request: Request) => Effect<Fetch.SuccessType, Fetch.ErrorType, never>>;
 /**
  * Fetch service for making or mocking HTTP requests.
  *
  * @example
- * ```
- * import { Fetch } from "fx-fetch";
+ * ```ts
+ * import { Effect } from 'effect';
+ * import { Fetch, Request } from 'fx-fetch';
  *
  * Effect.gen(function* () {
- *   const request = new Request('https://example.com');
+ *   const request = Request.unsafeMake({ url: 'https://example.com' });
  *
  *   const fetch = yield* Fetch.Fetch; // ◀︎── Get the Fetch service
  *   const response = yield* fetch(request);
  * }).pipe(
- *   Effect.provideService(Fetch.Fetch, Fetch.layer), // ◀︎── Provide built-in Fetch service
+ *   Effect.provide(Fetch.layer), // ◀︎── Provide built-in Fetch layer
  *   Effect.runPromise
  * );
  * ```

package/dist/Fetch/Fetch.js

@@ -3,16 +3,17 @@ import { Tag } from 'effect/Context';
  * Fetch service for making or mocking HTTP requests.
  *
  * @example
- * ```
- * import { Fetch } from "fx-fetch";
+ * ```ts
+ * import { Effect } from 'effect';
+ * import { Fetch, Request } from 'fx-fetch';
  *
  * Effect.gen(function* () {
- *   const request = new Request('https://example.com');
+ *   const request = Request.unsafeMake({ url: 'https://example.com' });
  *
  *   const fetch = yield* Fetch.Fetch; // ◀︎── Get the Fetch service
  *   const response = yield* fetch(request);
  * }).pipe(
- *   Effect.provideService(Fetch.Fetch, Fetch.layer), // ◀︎── Provide built-in Fetch service
+ *   Effect.provide(Fetch.layer), // ◀︎── Provide built-in Fetch layer
  *   Effect.runPromise
  * );
  * ```

package/dist/Fetch/Fetch.js.map

@@ -1 +1 @@
-{"version":3,"file":"Fetch.js","sourceRoot":"","sources":["../../src/Fetch/Fetch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AAMrC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,OAAO,KAAM,SAAQ,GAAG,CAAC,gBAAgB,CAAC,EAK7C;CAAG"}
+{"version":3,"file":"Fetch.js","sourceRoot":"","sources":["../../src/Fetch/Fetch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AAsBrC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,OAAO,KAAM,SAAQ,GAAG,CAAC,gBAAgB,CAAC,EAG7C;CAAG"}

package/dist/Fetch/FetchLive.d.ts

@@ -1,8 +1,33 @@
 import type { Type } from "./Type.js";
 /**
- * Fetch a request and handle the response.
+ * Live implementation of the Fetch service that performs actual HTTP requests.
  *
- * @category Layers
+ * @example
+ * ```ts
+ * import { Effect } from 'effect';
+ * import { Fetch, Request, Response } from 'fx-fetch';
+ *
+ * //       ┌─── Effect.Effect<
+ * //       │      Response.Response,
+ * //       │      | Fetch.FetchError
+ * //       │      | Fetch.AbortError
+ * //       │      | Fetch.NotAllowedError
+ * //       │      | Response.NotOkError,
+ * //       │      never
+ * //       │    >
+ * //       ▼
+ * const program = Effect.gen(function* () {
+ *   const request = Request.unsafeMake({ url: 'https://example.com' });
+ *
+ *   //       ┌─── Response.Response
+ *   //       ▼
+ *   const response = yield* Fetch.FetchLive(request);
+ *
+ *   return response;
+ * });
+ * ```
+ *
+ * @category Services
  * @since 0.1.0
  */
 export declare const FetchLive: Type;

package/dist/Fetch/FetchLive.js

@@ -1,47 +1,36 @@
-import { RuntimeException } from 'effect/Cause';
-import { dieMessage, flatMap, map, succeed, tryPromise } from 'effect/Effect';
-import { match } from 'effect/Option';
-import { toJsRequestPromise } from "../Request/index.js";
-import { ensureOk, make } from "../Response/index.js";
-import { getErrorMessage } from "../utils/getErrorMessage.js";
-import { AbortError, FetchError, NotAllowedError } from "./errors.js";
-// TODO: Add examples
+import { flatMap } from 'effect/Effect';
+import { ensureOk } from "../Response/index.js";
+import { executeFetch } from "./executeFetch.js";
 /**
- * Fetch a request and handle the response.
+ * Live implementation of the Fetch service that performs actual HTTP requests.
  *
- * @category Layers
+ * @example
+ * ```ts
+ * import { Effect } from 'effect';
+ * import { Fetch, Request, Response } from 'fx-fetch';
+ *
+ * //       ┌─── Effect.Effect<
+ * //       │      Response.Response,
+ * //       │      | Fetch.FetchError
+ * //       │      | Fetch.AbortError
+ * //       │      | Fetch.NotAllowedError
+ * //       │      | Response.NotOkError,
+ * //       │      never
+ * //       │    >
+ * //       ▼
+ * const program = Effect.gen(function* () {
+ *   const request = Request.unsafeMake({ url: 'https://example.com' });
+ *
+ *   //       ┌─── Response.Response
+ *   //       ▼
+ *   const response = yield* Fetch.FetchLive(request);
+ *
+ *   return response;
+ * });
+ * ```
+ *
+ * @category Services
  * @since 0.1.0
  */
-export const FetchLive = (request) => tryPromise({
-    try: async (signal) => {
-        const jsRequest = await toJsRequestPromise(request, { signal });
-        return await globalThis.fetch(jsRequest);
-    },
-    catch(error) {
-        if (error instanceof TypeError) {
-            return new FetchError({
-                message: error.message,
-                cause: error,
-            });
-        }
-        if (typeof error === 'object' && error !== null && 'name' in error) {
-            if (error.name === 'AbortError') {
-                return new AbortError({
-                    message: getErrorMessage(error, 'Http request aborted'),
-                    cause: error,
-                });
-            }
-            if (error.name === 'NotAllowedError') {
-                return new NotAllowedError({
-                    message: getErrorMessage(error, 'Http request not allowed'),
-                    cause: error,
-                });
-            }
-        }
-        throw new RuntimeException(getErrorMessage(error, 'Unknown error occurred during fetch request'));
-    },
-}).pipe(map(make), flatMap(match({
-    onSome: succeed,
-    onNone: () => dieMessage('Failed to create Response from fetch response'),
-})), flatMap(ensureOk));
+export const FetchLive = (request) => executeFetch(request).pipe(flatMap(ensureOk));
 //# sourceMappingURL=FetchLive.js.map

package/dist/Fetch/FetchLive.js.map

@@ -1 +1 @@
-{"version":3,"file":"FetchLive.js","sourceRoot":"","sources":["../../src/Fetch/FetchLive.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC9E,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AACtC,OAAO,EAAgB,kBAAkB,EAAE,4BAAmB;AAC9D,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,6BAAoB;AAC7C,OAAO,EAAE,eAAe,EAAE,oCAAiC;AAC3D,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,eAAe,EAAE,oBAAiB;AAGnE,qBAAqB;AAErB;;;;;GAKG;AACH,MAAM,CAAC,MAAM,SAAS,GAAS,CAAC,OAAgB,EAAE,EAAE,CAClD,UAAU,CAAC;IACT,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE;QACpB,MAAM,SAAS,GAAG,MAAM,kBAAkB,CAAC,OAAO,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC;QAChE,OAAO,MAAM,UAAU,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;IAC3C,CAAC;IACD,KAAK,CAAC,KAAK;QACT,IAAI,KAAK,YAAY,SAAS,EAAE,CAAC;YAC/B,OAAO,IAAI,UAAU,CAAC;gBACpB,OAAO,EAAE,KAAK,CAAC,OAAO;gBACtB,KAAK,EAAE,KAAK;aACb,CAAC,CAAC;QACL,CAAC;QAED,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,IAAI,MAAM,IAAI,KAAK,EAAE,CAAC;YACnE,IAAI,KAAK,CAAC,IAAI,KAAK,YAAY,EAAE,CAAC;gBAChC,OAAO,IAAI,UAAU,CAAC;oBACpB,OAAO,EAAE,eAAe,CAAC,KAAK,EAAE,sBAAsB,CAAC;oBACvD,KAAK,EAAE,KAAK;iBACb,CAAC,CAAC;YACL,CAAC;YAED,IAAI,KAAK,CAAC,IAAI,KAAK,iBAAiB,EAAE,CAAC;gBACrC,OAAO,IAAI,eAAe,CAAC;oBACzB,OAAO,EAAE,eAAe,CAAC,KAAK,EAAE,0BAA0B,CAAC;oBAC3D,KAAK,EAAE,KAAK;iBACb,CAAC,CAAC;YACL,CAAC;QACH,CAAC;QAED,MAAM,IAAI,gBAAgB,CACxB,eAAe,CAAC,KAAK,EAAE,6CAA6C,CAAC,CACtE,CAAC;IACJ,CAAC;CACF,CAAC,CAAC,IAAI,CACL,GAAG,CAAC,IAAI,CAAC,EACT,OAAO,CACL,KAAK,CAAC;IACJ,MAAM,EAAE,OAAO;IACf,MAAM,EAAE,GAAG,EAAE,CAAC,UAAU,CAAC,+CAA+C,CAAC;CAC1E,CAAC,CACH,EACD,OAAO,CAAC,QAAQ,CAAC,CAClB,CAAC"}
+{"version":3,"file":"FetchLive.js","sourceRoot":"","sources":["../../src/Fetch/FetchLive.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAExC,OAAO,EAAE,QAAQ,EAAE,6BAAoB;AACvC,OAAO,EAAE,YAAY,EAAE,0BAAuB;AAG9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,CAAC,MAAM,SAAS,GAAS,CAAC,OAAgB,EAAE,EAAE,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC"}

package/dist/Fetch/executeFetch.d.ts

@@ -0,0 +1,9 @@
+import { type Request } from "../Request/index.js";
+import { type Response } from "../Response/index.js";
+import { AbortError, FetchError, NotAllowedError } from "./errors.js";
+/**
+ * Core implementation of fetch execution.
+ *
+ * @internal
+ */
+export declare const executeFetch: (request: Request) => import("effect/Effect").Effect<Response, FetchError | AbortError | NotAllowedError, never>;

package/dist/Fetch/executeFetch.js

@@ -0,0 +1,45 @@
+import { RuntimeException } from 'effect/Cause';
+import { dieMessage, ensureErrorType, ensureRequirementsType, ensureSuccessType, flatMap, map, succeed, tryPromise, } from 'effect/Effect';
+import { match } from 'effect/Option';
+import { toJsRequestPromise } from "../Request/index.js";
+import { make as makeResponse } from "../Response/index.js";
+import { getErrorMessage } from "../utils/getErrorMessage.js";
+import { AbortError, FetchError, NotAllowedError } from "./errors.js";
+/**
+ * Core implementation of fetch execution.
+ *
+ * @internal
+ */
+export const executeFetch = (request) => tryPromise({
+    try: async (signal) => {
+        const jsRequest = await toJsRequestPromise(request, { signal });
+        return await globalThis.fetch(jsRequest);
+    },
+    catch(error) {
+        if (error instanceof TypeError) {
+            return new FetchError({
+                message: error.message,
+                cause: error,
+            });
+        }
+        if (typeof error === 'object' && error !== null && 'name' in error) {
+            if (error.name === 'AbortError') {
+                return new AbortError({
+                    message: getErrorMessage(error, 'Http request aborted'),
+                    cause: error,
+                });
+            }
+            if (error.name === 'NotAllowedError') {
+                return new NotAllowedError({
+                    message: getErrorMessage(error, 'Http request not allowed'),
+                    cause: error,
+                });
+            }
+        }
+        throw new RuntimeException(getErrorMessage(error, 'Unknown error occurred during fetch request'));
+    },
+}).pipe(map(makeResponse), flatMap(match({
+    onSome: succeed,
+    onNone: () => dieMessage('Failed to create Response from fetch response'),
+})), ensureSuccessType(), ensureErrorType(), ensureRequirementsType());
+//# sourceMappingURL=executeFetch.js.map

package/dist/Fetch/executeFetch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"executeFetch.js","sourceRoot":"","sources":["../../src/Fetch/executeFetch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,EACL,UAAU,EACV,eAAe,EACf,sBAAsB,EACtB,iBAAiB,EACjB,OAAO,EACP,GAAG,EACH,OAAO,EACP,UAAU,GACX,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AACtC,OAAO,EAAgB,kBAAkB,EAAE,4BAAmB;AAC9D,OAAO,EAAE,IAAI,IAAI,YAAY,EAAiB,6BAAoB;AAClE,OAAO,EAAE,eAAe,EAAE,oCAAiC;AAC3D,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,eAAe,EAAE,oBAAiB;AAEnE;;;;GAIG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,OAAgB,EAAE,EAAE,CAC/C,UAAU,CAAC;IACT,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE;QACpB,MAAM,SAAS,GAAG,MAAM,kBAAkB,CAAC,OAAO,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC;QAChE,OAAO,MAAM,UAAU,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;IAC3C,CAAC;IACD,KAAK,CAAC,KAAK;QACT,IAAI,KAAK,YAAY,SAAS,EAAE,CAAC;YAC/B,OAAO,IAAI,UAAU,CAAC;gBACpB,OAAO,EAAE,KAAK,CAAC,OAAO;gBACtB,KAAK,EAAE,KAAK;aACb,CAAC,CAAC;QACL,CAAC;QAED,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,IAAI,MAAM,IAAI,KAAK,EAAE,CAAC;YACnE,IAAI,KAAK,CAAC,IAAI,KAAK,YAAY,EAAE,CAAC;gBAChC,OAAO,IAAI,UAAU,CAAC;oBACpB,OAAO,EAAE,eAAe,CAAC,KAAK,EAAE,sBAAsB,CAAC;oBACvD,KAAK,EAAE,KAAK;iBACb,CAAC,CAAC;YACL,CAAC;YAED,IAAI,KAAK,CAAC,IAAI,KAAK,iBAAiB,EAAE,CAAC;gBACrC,OAAO,IAAI,eAAe,CAAC;oBACzB,OAAO,EAAE,eAAe,CAAC,KAAK,EAAE,0BAA0B,CAAC;oBAC3D,KAAK,EAAE,KAAK;iBACb,CAAC,CAAC;YACL,CAAC;QACH,CAAC;QAED,MAAM,IAAI,gBAAgB,CACxB,eAAe,CAAC,KAAK,EAAE,6CAA6C,CAAC,CACtE,CAAC;IACJ,CAAC;CACF,CAAC,CAAC,IAAI,CACL,GAAG,CAAC,YAAY,CAAC,EACjB,OAAO,CACL,KAAK,CAAC;IACJ,MAAM,EAAE,OAAO;IACf,MAAM,EAAE,GAAG,EAAE,CAAC,UAAU,CAAC,+CAA+C,CAAC;CAC1E,CAAC,CACH,EACD,iBAAiB,EAAY,EAC7B,eAAe,EAA6C,EAC5D,sBAAsB,EAAS,CAChC,CAAC"}

package/dist/Fetch/fetchArrayBuffer.d.ts

@@ -5,4 +5,4 @@ import type { Request } from "../Request/index.js";
  * @category Functions
  * @since 0.1.0
  */
-export declare const fetchArrayBuffer: (request: Request) => import("effect/Effect").Effect<ArrayBuffer, import("../Cause").MalformedArrayBufferError | import("./errors").FetchError | import("./errors").AbortError | import("./errors").NotAllowedError | import("../Response").NotOkError, import("./Fetch").Fetch>;
+export declare const fetchArrayBuffer: (request: Request) => import("effect/Effect").Effect<ArrayBuffer, import("../Cause").MalformedArrayBufferError | import("./Fetch").Fetch.ErrorType, import("./Fetch").Fetch>;

package/dist/Fetch/fetchBlob.d.ts

@@ -29,4 +29,4 @@ import type { Request } from "../Request/index.js";
  * });
  * ```
  */
-export declare const fetchBlob: (request: Request) => import("effect/Effect").Effect<Blob, import("../Cause").MalformedBlobError | import("./errors").FetchError | import("./errors").AbortError | import("./errors").NotAllowedError | import("../Response").NotOkError, import("./Fetch").Fetch>;
+export declare const fetchBlob: (request: Request) => import("effect/Effect").Effect<Blob, import("../Cause").MalformedBlobError | import("./Fetch").Fetch.ErrorType, import("./Fetch").Fetch>;

package/dist/Fetch/fetchBytes.d.ts

@@ -29,4 +29,4 @@ import type { Request } from "../Request/index.js";
  * });
  * ```
  */
-export declare const fetchBytes: (request: Request) => import("effect/Effect").Effect<Uint8Array<ArrayBufferLike>, import("../Cause").MalformedBytesError | import("./errors").FetchError | import("./errors").AbortError | import("./errors").NotAllowedError | import("../Response").NotOkError, import("./Fetch").Fetch>;
+export declare const fetchBytes: (request: Request) => import("effect/Effect").Effect<Uint8Array<ArrayBufferLike>, import("../Cause").MalformedBytesError | import("./Fetch").Fetch.ErrorType, import("./Fetch").Fetch>;

package/dist/Fetch/fetchFn.d.ts

@@ -32,4 +32,4 @@ import { Fetch } from "./Fetch.js";
  * );
  * ```
  */
-export declare const fetch: (request: Request) => import("effect/Effect").Effect<import("../Response").Response, import("./errors").FetchError | import("./errors").AbortError | import("./errors").NotAllowedError | import("../Response").NotOkError, Fetch>;
+export declare const fetch: (request: Request) => import("effect/Effect").Effect<import("../Response").Response, Fetch.ErrorType, Fetch>;

package/dist/Fetch/fetchFormData.d.ts

@@ -29,4 +29,4 @@ import type { Request } from "../Request/index.js";
  * });
  * ```
  */
-export declare const fetchFormData: (request: Request) => import("effect/Effect").Effect<FormData, import("../Cause").MalformedFormDataError | import("./errors").FetchError | import("./errors").AbortError | import("./errors").NotAllowedError | import("../Response").NotOkError, import("./Fetch").Fetch>;
+export declare const fetchFormData: (request: Request) => import("effect/Effect").Effect<FormData, import("../Cause").MalformedFormDataError | import("./Fetch").Fetch.ErrorType, import("./Fetch").Fetch>;

package/dist/Fetch/fetchJson.d.ts

@@ -29,4 +29,4 @@ import type { Request } from "../Request/index.js";
  * });
  * ```
  */
-export declare const fetchJson: (request: Request) => import("effect/Effect").Effect<unknown, import("../Cause").MalformedJsonError | import("./errors").FetchError | import("./errors").AbortError | import("./errors").NotAllowedError | import("../Response").NotOkError, import("./Fetch").Fetch>;
+export declare const fetchJson: (request: Request) => import("effect/Effect").Effect<unknown, import("../Cause").MalformedJsonError | import("./Fetch").Fetch.ErrorType, import("./Fetch").Fetch>;

package/dist/Fetch/fetchReadableStream.d.ts

@@ -29,4 +29,4 @@ import type { Request } from "../Request/index.js";
  * });
  * ```
  */
-export declare const fetchReadableStream: (request: Request) => import("effect/Effect").Effect<import("../utils/localThis").ReadableStream<Uint8Array<ArrayBufferLike>>, import("../Cause").MalformedReadableStreamError | import("./errors").FetchError | import("./errors").AbortError | import("./errors").NotAllowedError | import("../Response").NotOkError, import("./Fetch").Fetch>;
+export declare const fetchReadableStream: (request: Request) => import("effect/Effect").Effect<import("../utils/localThis").ReadableStream<Uint8Array<ArrayBufferLike>>, import("../Cause").MalformedReadableStreamError | import("./Fetch").Fetch.ErrorType, import("./Fetch").Fetch>;

package/dist/Fetch/fetchText.d.ts

@@ -29,4 +29,4 @@ import type { Request } from "../Request/index.js";
  * });
  * ```
  */
-export declare const fetchText: (request: Request) => import("effect/Effect").Effect<string, import("../Cause").MalformedTextError | import("./errors").FetchError | import("./errors").AbortError | import("./errors").NotAllowedError | import("../Response").NotOkError, import("./Fetch").Fetch>;
+export declare const fetchText: (request: Request) => import("effect/Effect").Effect<string, import("../Cause").MalformedTextError | import("./Fetch").Fetch.ErrorType, import("./Fetch").Fetch>;

package/dist/Fetch/index.d.ts

@@ -11,6 +11,9 @@ export { fetchJsonWithSchema } from "./fetchJsonWithSchema.js";
 export { fetchReadableStream } from "./fetchReadableStream.js";
 export { fetchStream } from "./fetchStream.js";
 export { fetchText } from "./fetchText.js";
+export { layer } from "./layer.js";
+export { makeMiddlewareLayer } from "./makeMiddlewareLayer.js";
+export { makeMockLayer } from "./makeMockLayer.js";
 export { paginatedFetch } from "./paginatedFetch.js";
 export { paginatedFetchStream } from "./paginatedFetchStream.js";
 export type { Type } from "./Type.js";

package/dist/Fetch/index.js

@@ -11,6 +11,9 @@ export { fetchJsonWithSchema } from "./fetchJsonWithSchema.js";
 export { fetchReadableStream } from "./fetchReadableStream.js";
 export { fetchStream } from "./fetchStream.js";
 export { fetchText } from "./fetchText.js";
+export { layer } from "./layer.js";
+export { makeMiddlewareLayer } from "./makeMiddlewareLayer.js";
+export { makeMockLayer } from "./makeMockLayer.js";
 export { paginatedFetch } from "./paginatedFetch.js";
 export { paginatedFetchStream } from "./paginatedFetchStream.js";
 //# sourceMappingURL=index.js.map

package/dist/Fetch/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/Fetch/index.ts"],"names":[],"mappings":"AAAA,4BAAyB;AACzB,OAAO,EAAE,KAAK,EAAE,mBAAgB;AAChC,OAAO,EAAE,SAAS,EAAE,uBAAoB;AACxC,OAAO,EAAE,gBAAgB,EAAE,8BAA2B;AACtD,OAAO,EAAE,SAAS,EAAE,uBAAoB;AACxC,OAAO,EAAE,UAAU,EAAE,wBAAqB;AAC1C,OAAO,EAAE,KAAK,EAAE,qBAAkB;AAClC,OAAO,EAAE,aAAa,EAAE,2BAAwB;AAChD,OAAO,EAAE,SAAS,EAAE,uBAAoB;AACxC,OAAO,EAAE,mBAAmB,EAAE,iCAA8B;AAC5D,OAAO,EAAE,mBAAmB,EAAE,iCAA8B;AAC5D,OAAO,EAAE,WAAW,EAAE,yBAAsB;AAC5C,OAAO,EAAE,SAAS,EAAE,uBAAoB;AACxC,OAAO,EAAE,cAAc,EAAE,4BAAyB;AAClD,OAAO,EAAE,oBAAoB,EAAE,kCAA+B"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/Fetch/index.ts"],"names":[],"mappings":"AAAA,4BAAyB;AACzB,OAAO,EAAE,KAAK,EAAE,mBAAgB;AAChC,OAAO,EAAE,SAAS,EAAE,uBAAoB;AACxC,OAAO,EAAE,gBAAgB,EAAE,8BAA2B;AACtD,OAAO,EAAE,SAAS,EAAE,uBAAoB;AACxC,OAAO,EAAE,UAAU,EAAE,wBAAqB;AAC1C,OAAO,EAAE,KAAK,EAAE,qBAAkB;AAClC,OAAO,EAAE,aAAa,EAAE,2BAAwB;AAChD,OAAO,EAAE,SAAS,EAAE,uBAAoB;AACxC,OAAO,EAAE,mBAAmB,EAAE,iCAA8B;AAC5D,OAAO,EAAE,mBAAmB,EAAE,iCAA8B;AAC5D,OAAO,EAAE,WAAW,EAAE,yBAAsB;AAC5C,OAAO,EAAE,SAAS,EAAE,uBAAoB;AACxC,OAAO,EAAE,KAAK,EAAE,mBAAgB;AAChC,OAAO,EAAE,mBAAmB,EAAE,iCAA8B;AAC5D,OAAO,EAAE,aAAa,EAAE,2BAAwB;AAChD,OAAO,EAAE,cAAc,EAAE,4BAAyB;AAClD,OAAO,EAAE,oBAAoB,EAAE,kCAA+B"}

package/dist/Fetch/layer.d.ts

@@ -0,0 +1,27 @@
+import { type Layer } from 'effect/Layer';
+import { Fetch } from "./Fetch.js";
+/**
+ * Fetch layer providing the live implementation.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from 'effect';
+ * import { Fetch, Request } from 'fx-fetch';
+ *
+ * const program = Effect.gen(function* () {
+ *   const request = Request.unsafeMake({ url: 'https://example.com' });
+ *   const response = yield* Fetch.fetch(request);
+ *
+ *   return response;
+ * });
+ *
+ * program.pipe(
+ *   Effect.provide(Fetch.layer), // ◀︎── Provide Fetch layer
+ *   Effect.runPromise
+ * );
+ * ```
+ *
+ * @category Layers
+ * @since 1.2.0
+ */
+export declare const layer: Layer<Fetch, never, never>;

package/dist/Fetch/layer.js

@@ -0,0 +1,29 @@
+import { succeed as layerSucceed } from 'effect/Layer';
+import { Fetch } from "./Fetch.js";
+import { FetchLive } from "./FetchLive.js";
+/**
+ * Fetch layer providing the live implementation.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from 'effect';
+ * import { Fetch, Request } from 'fx-fetch';
+ *
+ * const program = Effect.gen(function* () {
+ *   const request = Request.unsafeMake({ url: 'https://example.com' });
+ *   const response = yield* Fetch.fetch(request);
+ *
+ *   return response;
+ * });
+ *
+ * program.pipe(
+ *   Effect.provide(Fetch.layer), // ◀︎── Provide Fetch layer
+ *   Effect.runPromise
+ * );
+ * ```
+ *
+ * @category Layers
+ * @since 1.2.0
+ */
+export const layer = layerSucceed(Fetch, FetchLive);
+//# sourceMappingURL=layer.js.map

package/dist/Fetch/layer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"layer.js","sourceRoot":"","sources":["../../src/Fetch/layer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,OAAO,IAAI,YAAY,EAAE,MAAM,cAAc,CAAC;AACnE,OAAO,EAAE,KAAK,EAAE,mBAAgB;AAChC,OAAO,EAAE,SAAS,EAAE,uBAAoB;AAExC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,CAAC,MAAM,KAAK,GAA+B,YAAY,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC"}

package/dist/Fetch/makeMiddlewareLayer.d.ts

@@ -0,0 +1,70 @@
+import { type Effect } from 'effect/Effect';
+import { type Layer } from 'effect/Layer';
+import type { Request } from "../Request/index.js";
+import { type Response } from "../Response/index.js";
+import { Fetch } from "./Fetch.js";
+type MiddlewareOptions<R1, R2> = {
+    readonly mapRequest?: (request: Request) => Effect<Request, never, R1>;
+    readonly mapResponse?: (response: Response) => Effect<Response, Fetch.ErrorType, R2>;
+};
+/**
+ * Creates a middleware Layer that allows customizing request and response handling.
+ *
+ * The middleware can transform requests before they are sent and responses after they are received.
+ * Both `mapRequest` and `mapResponse` are optional - if not provided, they pass through unchanged.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from 'effect';
+ * import { Fetch, Request } from 'fx-fetch';
+ *
+ * // Middleware that adds authorization header to all requests
+ * const authMiddlewareLayer = Fetch.makeMiddlewareLayer({
+ *   mapRequest: (request) =>
+ *     Effect.succeed(
+ *       Request.appendHeaders(request, { Authorization: 'Bearer token' })
+ *     ),
+ * });
+ *
+ * Effect.gen(function* () {
+ *   const request = Request.unsafeMake({ url: 'https://api.example.com/data' });
+ *   const response = yield* Fetch.fetch(request);
+ * }).pipe(
+ *   Effect.provide(authMiddlewareLayer), // ◀︎── Provide middleware layer
+ *   Effect.runPromise
+ * );
+ * ```
+ *
+ * @example
+ * ```ts
+ * import { Context, Effect, Layer } from 'effect';
+ * import { Fetch, Request } from 'fx-fetch';
+ *
+ * // Service for configuration
+ * class Config extends Context.Tag('Config')<Config, { apiKey: string }>() {}
+ *
+ * // Middleware with requirements - the Layer properly tracks Config requirement
+ * const authMiddlewareLayer = Fetch.makeMiddlewareLayer({
+ *   mapRequest: (request) =>
+ *     Effect.gen(function* () {
+ *       const config = yield* Config;
+ *       return Request.appendHeaders(request, { 'X-API-Key': config.apiKey });
+ *     }),
+ * });
+ * // Type: Layer<Fetch, never, Config>
+ *
+ * Effect.gen(function* () {
+ *   const request = Request.unsafeMake({ url: 'https://api.example.com/data' });
+ *   const response = yield* Fetch.fetch(request);
+ * }).pipe(
+ *   Effect.provide(authMiddlewareLayer),
+ *   Effect.provide(Layer.succeed(Config, { apiKey: 'secret' })),
+ *   Effect.runPromise
+ * );
+ * ```
+ *
+ * @category Layers
+ * @since 1.2.0
+ */
+export declare const makeMiddlewareLayer: <R1 = never, R2 = never>(options: MiddlewareOptions<R1, R2>) => Layer<Fetch, never, R1 | R2>;
+export {};

package/dist/Fetch/makeMiddlewareLayer.js

@@ -0,0 +1,75 @@
+import { context, flatMap, gen, provide, succeed } from 'effect/Effect';
+import { effect as layerEffect } from 'effect/Layer';
+import { ensureOk } from "../Response/index.js";
+import { executeFetch } from "./executeFetch.js";
+import { Fetch } from "./Fetch.js";
+/**
+ * Creates a middleware Layer that allows customizing request and response handling.
+ *
+ * The middleware can transform requests before they are sent and responses after they are received.
+ * Both `mapRequest` and `mapResponse` are optional - if not provided, they pass through unchanged.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from 'effect';
+ * import { Fetch, Request } from 'fx-fetch';
+ *
+ * // Middleware that adds authorization header to all requests
+ * const authMiddlewareLayer = Fetch.makeMiddlewareLayer({
+ *   mapRequest: (request) =>
+ *     Effect.succeed(
+ *       Request.appendHeaders(request, { Authorization: 'Bearer token' })
+ *     ),
+ * });
+ *
+ * Effect.gen(function* () {
+ *   const request = Request.unsafeMake({ url: 'https://api.example.com/data' });
+ *   const response = yield* Fetch.fetch(request);
+ * }).pipe(
+ *   Effect.provide(authMiddlewareLayer), // ◀︎── Provide middleware layer
+ *   Effect.runPromise
+ * );
+ * ```
+ *
+ * @example
+ * ```ts
+ * import { Context, Effect, Layer } from 'effect';
+ * import { Fetch, Request } from 'fx-fetch';
+ *
+ * // Service for configuration
+ * class Config extends Context.Tag('Config')<Config, { apiKey: string }>() {}
+ *
+ * // Middleware with requirements - the Layer properly tracks Config requirement
+ * const authMiddlewareLayer = Fetch.makeMiddlewareLayer({
+ *   mapRequest: (request) =>
+ *     Effect.gen(function* () {
+ *       const config = yield* Config;
+ *       return Request.appendHeaders(request, { 'X-API-Key': config.apiKey });
+ *     }),
+ * });
+ * // Type: Layer<Fetch, never, Config>
+ *
+ * Effect.gen(function* () {
+ *   const request = Request.unsafeMake({ url: 'https://api.example.com/data' });
+ *   const response = yield* Fetch.fetch(request);
+ * }).pipe(
+ *   Effect.provide(authMiddlewareLayer),
+ *   Effect.provide(Layer.succeed(Config, { apiKey: 'secret' })),
+ *   Effect.runPromise
+ * );
+ * ```
+ *
+ * @category Layers
+ * @since 1.2.0
+ */
+export const makeMiddlewareLayer = (options) => {
+    const mapRequest = options.mapRequest ?? ((request) => succeed(request));
+    const mapResponse = options.mapResponse ?? ((response) => succeed(response));
+    const makeService = gen(function* () {
+        const ctx = yield* context();
+        const service = (request) => mapRequest(request).pipe(flatMap(executeFetch), flatMap(mapResponse), flatMap(ensureOk), provide(ctx));
+        return service;
+    });
+    return layerEffect(Fetch, makeService);
+};
+//# sourceMappingURL=makeMiddlewareLayer.js.map

package/dist/Fetch/makeMiddlewareLayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeMiddlewareLayer.js","sourceRoot":"","sources":["../../src/Fetch/makeMiddlewareLayer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAe,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AACrF,OAAO,EAAc,MAAM,IAAI,WAAW,EAAE,MAAM,cAAc,CAAC;AAEjE,OAAO,EAAE,QAAQ,EAAiB,6BAAoB;AACtD,OAAO,EAAE,YAAY,EAAE,0BAAuB;AAC9C,OAAO,EAAE,KAAK,EAAE,mBAAgB;AAQhC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CACjC,OAAkC,EACJ,EAAE;IAChC,MAAM,UAAU,GAAG,OAAO,CAAC,UAAU,IAAI,CAAC,CAAC,OAAgB,EAAE,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;IAClF,MAAM,WAAW,GAAG,OAAO,CAAC,WAAW,IAAI,CAAC,CAAC,QAAkB,EAAE,EAAE,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;IAEvF,MAAM,WAAW,GAAG,GAAG,CAAC,QAAQ,CAAC;QAC/B,MAAM,GAAG,GAAG,KAAK,CAAC,CAAC,OAAO,EAAW,CAAC;QAEtC,MAAM,OAAO,GAAS,CAAC,OAAgB,EAAE,EAAE,CACzC,UAAU,CAAC,OAAO,CAAC,CAAC,IAAI,CACtB,OAAO,CAAC,YAAY,CAAC,EACrB,OAAO,CAAC,WAAW,CAAC,EACpB,OAAO,CAAC,QAAQ,CAAC,EACjB,OAAO,CAAC,GAAG,CAAC,CACb,CAAC;QAEJ,OAAO,OAAO,CAAC;IACjB,CAAC,CAAC,CAAC;IAEH,OAAO,WAAW,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;AACzC,CAAC,CAAC"}

package/dist/Fetch/makeMockLayer.d.ts

@@ -0,0 +1,50 @@
+import { type Effect } from 'effect/Effect';
+import { type Layer } from 'effect/Layer';
+import type { Request } from "../Request/index.js";
+import { Fetch } from "./Fetch.js";
+type MockFn = (request: Request) => Fetch.SuccessType | Effect<Fetch.SuccessType, Fetch.ErrorType, never>;
+/**
+ * Creates a mock Fetch layer for testing purposes.
+ *
+ * The mock function can return either a plain `Response` or an `Effect<Response, E>`
+ * for simulating both successful responses and error scenarios.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from 'effect';
+ * import { Fetch, Request, Response } from 'fx-fetch';
+ *
+ * // Mock returning a simple Response
+ * const mockLayer = Fetch.makeMockLayer(() =>
+ *   Response.unsafeMake({ status: 200, ok: true, body: 'Hello' })
+ * );
+ *
+ * Effect.gen(function* () {
+ *   const request = Request.unsafeMake({ url: 'https://example.com' });
+ *   const response = yield* Fetch.fetch(request);
+ * }).pipe(
+ *   Effect.provide(mockLayer), // ◀︎── Provide mock layer
+ *   Effect.runPromise
+ * );
+ * ```
+ *
+ * @example
+ * ```ts
+ * import { Effect } from 'effect';
+ * import { Fetch, Request, Response, Url } from 'fx-fetch';
+ *
+ * // Mock using the request to return different responses
+ * const mockLayer = Fetch.makeMockLayer((request) => {
+ *   if (Url.format(request.url).includes('/users')) {
+ *     return Response.unsafeMake({ status: 200, ok: true, body: JSON.stringify([{ id: 1 }]) });
+ *   }
+ *
+ *   return Response.unsafeMake({ status: 404, ok: false });
+ * });
+ * ```
+ *
+ * @category Layers
+ * @since 1.2.0
+ */
+export declare const makeMockLayer: (mockFn: MockFn) => Layer<Fetch, never, never>;
+export {};

package/dist/Fetch/makeMockLayer.js

@@ -0,0 +1,56 @@
+import { flatMap, isEffect, succeed } from 'effect/Effect';
+import { succeed as layerSucceed } from 'effect/Layer';
+import { ensureOk } from "../Response/index.js";
+import { Fetch } from "./Fetch.js";
+/**
+ * Creates a mock Fetch layer for testing purposes.
+ *
+ * The mock function can return either a plain `Response` or an `Effect<Response, E>`
+ * for simulating both successful responses and error scenarios.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from 'effect';
+ * import { Fetch, Request, Response } from 'fx-fetch';
+ *
+ * // Mock returning a simple Response
+ * const mockLayer = Fetch.makeMockLayer(() =>
+ *   Response.unsafeMake({ status: 200, ok: true, body: 'Hello' })
+ * );
+ *
+ * Effect.gen(function* () {
+ *   const request = Request.unsafeMake({ url: 'https://example.com' });
+ *   const response = yield* Fetch.fetch(request);
+ * }).pipe(
+ *   Effect.provide(mockLayer), // ◀︎── Provide mock layer
+ *   Effect.runPromise
+ * );
+ * ```
+ *
+ * @example
+ * ```ts
+ * import { Effect } from 'effect';
+ * import { Fetch, Request, Response, Url } from 'fx-fetch';
+ *
+ * // Mock using the request to return different responses
+ * const mockLayer = Fetch.makeMockLayer((request) => {
+ *   if (Url.format(request.url).includes('/users')) {
+ *     return Response.unsafeMake({ status: 200, ok: true, body: JSON.stringify([{ id: 1 }]) });
+ *   }
+ *
+ *   return Response.unsafeMake({ status: 404, ok: false });
+ * });
+ * ```
+ *
+ * @category Layers
+ * @since 1.2.0
+ */
+export const makeMockLayer = (mockFn) => {
+    const service = (request) => {
+        const result = mockFn(request);
+        const effect = isEffect(result) ? result : succeed(result);
+        return effect.pipe(flatMap(ensureOk));
+    };
+    return layerSucceed(Fetch, service);
+};
+//# sourceMappingURL=makeMockLayer.js.map

package/dist/Fetch/makeMockLayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeMockLayer.js","sourceRoot":"","sources":["../../src/Fetch/makeMockLayer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AACxE,OAAO,EAAc,OAAO,IAAI,YAAY,EAAE,MAAM,cAAc,CAAC;AAEnE,OAAO,EAAE,QAAQ,EAAE,6BAAoB;AACvC,OAAO,EAAE,KAAK,EAAE,mBAAgB;AAOhC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,MAAc,EAA8B,EAAE;IAC1E,MAAM,OAAO,GAAS,CAAC,OAAgB,EAAE,EAAE;QACzC,MAAM,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC;QAC/B,MAAM,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QAC3D,OAAO,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;IACxC,CAAC,CAAC;IAEF,OAAO,YAAY,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;AACtC,CAAC,CAAC"}

package/dist/Request/Request.d.ts

@@ -79,6 +79,6 @@ export declare namespace Request {
      * @category Models
      * @since 0.1.0
      */
-    type Input = Request | Parts | Options | localThis.Request;
+    type Input = Request | Parts | Options | localThis.Request | string;
 }
 export {};

package/dist/Request/classifyRequestInput.js

@@ -13,6 +13,12 @@ function isRequestOptions(input) {
  * @internal Determines the type of Request.Request.Input
  */
 export function classifyRequestInput(input) {
+    if (typeof input === 'string') {
+        return {
+            type: 'parts',
+            input: { url: input },
+        };
+    }
     if (isRequest(input)) {
         return {
             type: 'request',

package/dist/Request/classifyRequestInput.js.map

@@ -1 +1 @@
-{"version":3,"file":"classifyRequestInput.js","sourceRoot":"","sources":["../../src/Request/classifyRequestInput.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,uBAAoB;AAGxC,SAAS,WAAW,CAAC,KAAc;IACjC,OAAO,KAAK,YAAY,UAAU,CAAC,OAAO,CAAC;AAC7C,CAAC;AAED,SAAS,gBAAgB,CAAC,KAAsC;IAC9D,MAAM,eAAe,GAAG,cAAc,IAAI,KAAK,CAAC;IAEhD,IAAI,eAAe,EAAE,CAAC;QACpB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,oBAAoB,CAAC,KAAoB;IAiBvD,IAAI,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC;QACrB,OAAO;YACL,IAAI,EAAE,SAAS;YACf,KAAK;SACN,CAAC;IACJ,CAAC;IAED,IAAI,WAAW,CAAC,KAAK,CAAC,EAAE,CAAC;QACvB,OAAO;YACL,IAAI,EAAE,WAAW;YACjB,KAAK;SACN,CAAC;IACJ,CAAC;IAED,IAAI,gBAAgB,CAAC,KAAK,CAAC,EAAE,CAAC;QAC5B,OAAO;YACL,IAAI,EAAE,SAAS;YACf,KAAK;SACN,CAAC;IACJ,CAAC;IAED,OAAO;QACL,IAAI,EAAE,OAAO;QACb,KAAK,EAAE,KAAK;KACb,CAAC;AACJ,CAAC"}
+{"version":3,"file":"classifyRequestInput.js","sourceRoot":"","sources":["../../src/Request/classifyRequestInput.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,uBAAoB;AAGxC,SAAS,WAAW,CAAC,KAAc;IACjC,OAAO,KAAK,YAAY,UAAU,CAAC,OAAO,CAAC;AAC7C,CAAC;AAED,SAAS,gBAAgB,CAAC,KAAsC;IAC9D,MAAM,eAAe,GAAG,cAAc,IAAI,KAAK,CAAC;IAEhD,IAAI,eAAe,EAAE,CAAC;QACpB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,oBAAoB,CAAC,KAAoB;IAiBvD,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC9B,OAAO;YACL,IAAI,EAAE,OAAO;YACb,KAAK,EAAE,EAAE,GAAG,EAAE,KAAK,EAAE;SACtB,CAAC;IACJ,CAAC;IAED,IAAI,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC;QACrB,OAAO;YACL,IAAI,EAAE,SAAS;YACf,KAAK;SACN,CAAC;IACJ,CAAC;IAED,IAAI,WAAW,CAAC,KAAK,CAAC,EAAE,CAAC;QACvB,OAAO;YACL,IAAI,EAAE,WAAW;YACjB,KAAK;SACN,CAAC;IACJ,CAAC;IAED,IAAI,gBAAgB,CAAC,KAAK,CAAC,EAAE,CAAC;QAC5B,OAAO;YACL,IAAI,EAAE,SAAS;YACf,KAAK;SACN,CAAC;IACJ,CAAC;IAED,OAAO;QACL,IAAI,EAAE,OAAO;QACb,KAAK,EAAE,KAAK;KACb,CAAC;AACJ,CAAC"}

package/dist/Request/make.d.ts

@@ -13,6 +13,15 @@
  * });
  * ```
  *
+ * @example
+ * ```ts
+ * import { Request } from 'fx-fetch';
+ *
+ * //       ┌─── Option.Option<Request.Request>
+ * //       ▼
+ * const request = Request.make('https://example.com');
+ * ```
+ *
  * @category Constructors
  * @since 0.1.0
  */

package/dist/Request/make.js

@@ -15,6 +15,15 @@ import { unsafeMake } from "./unsafeMake.js";
  * });
  * ```
  *
+ * @example
+ * ```ts
+ * import { Request } from 'fx-fetch';
+ *
+ * //       ┌─── Option.Option<Request.Request>
+ * //       ▼
+ * const request = Request.make('https://example.com');
+ * ```
+ *
  * @category Constructors
  * @since 0.1.0
  */

package/dist/Request/make.js.map

@@ -1 +1 @@
-{"version":3,"file":"make.js","sourceRoot":"","sources":["../../src/Request/make.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,wBAAqB;AAE1C;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,aAAa,CAAC,UAAU,CAAC,CAAC"}
+{"version":3,"file":"make.js","sourceRoot":"","sources":["../../src/Request/make.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,wBAAqB;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,aAAa,CAAC,UAAU,CAAC,CAAC"}

package/dist/Request/unsafeMake.d.ts

@@ -14,6 +14,15 @@ import type { Request } from "./Request.js";
  * });
  * ```
  *
+ * @example
+ * ```ts
+ * import { Request } from 'fx-fetch';
+ *
+ * //       ┌─── Request.Request
+ * //       ▼
+ * const request = Request.unsafeMake('https://example.com');
+ * ```
+ *
  * @category Constructors
  * @since 0.1.0
  */

package/dist/Request/unsafeMake.js

@@ -1,7 +1,6 @@
 import { isLeft } from 'effect/Either';
 import { inputToRequestIntermediate } from "./inputToRequestIntermediate.js";
 import { makeFromRequestIntermediate } from "./makeFromRequestIntermediate.js";
-// TODO: Add tests for dual APIs
 /**
  * Creates a immutable Request object. Throws an error if the input is invalid.
  *
@@ -17,6 +16,15 @@ import { makeFromRequestIntermediate } from "./makeFromRequestIntermediate.js";
  * });
  * ```
  *
+ * @example
+ * ```ts
+ * import { Request } from 'fx-fetch';
+ *
+ * //       ┌─── Request.Request
+ * //       ▼
+ * const request = Request.unsafeMake('https://example.com');
+ * ```
+ *
  * @category Constructors
  * @since 0.1.0
  */

package/dist/Request/unsafeMake.js.map

@@ -1 +1 @@
-{"version":3,"file":"unsafeMake.js","sourceRoot":"","sources":["../../src/Request/unsafeMake.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACvC,OAAO,EAAE,0BAA0B,EAAE,wCAAqC;AAC1E,OAAO,EAAE,2BAA2B,EAAE,yCAAsC;AAG5E,gCAAgC;AAEhC;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,UAAU,CAAC,KAAoB;IAC7C,MAAM,YAAY,GAAG,0BAA0B,CAAC,KAAK,CAAC,CAAC;IACvD,IAAI,MAAM,CAAC,YAAY,CAAC,EAAE,CAAC;QACzB,MAAM,YAAY,CAAC,IAAI,CAAC;IAC1B,CAAC;IAED,OAAO,2BAA2B,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;AACzD,CAAC"}
+{"version":3,"file":"unsafeMake.js","sourceRoot":"","sources":["../../src/Request/unsafeMake.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACvC,OAAO,EAAE,0BAA0B,EAAE,wCAAqC;AAC1E,OAAO,EAAE,2BAA2B,EAAE,yCAAsC;AAG5E;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,UAAU,UAAU,CAAC,KAAoB;IAC7C,MAAM,YAAY,GAAG,0BAA0B,CAAC,KAAK,CAAC,CAAC;IACvD,IAAI,MAAM,CAAC,YAAY,CAAC,EAAE,CAAC;QACzB,MAAM,YAAY,CAAC,IAAI,CAAC;IAC1B,CAAC;IAED,OAAO,2BAA2B,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;AACzD,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fx-fetch",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "description": "Simple, immutable, clonable, and effect-based HTTP fetching.",
   "keywords": [
     "clonable",
@@ -66,12 +66,12 @@
     "validate": "tsc"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.3.11",
-    "@effect/language-service": "^0.67.0",
+    "@biomejs/biome": "^2.3.14",
+    "@effect/language-service": "^0.73.1",
     "@types/node": "^24",
-    "dpdm": "^3.14.0",
+    "dpdm": "^4.0.1",
     "typescript": "^5.9.3",
-    "vitest": "^4.0.17",
+    "vitest": "^4.0.18",
     "zshy": "^0.7.0"
   },
   "peerDependencies": {