@akterjs/cli 0.0.0-stage → 0.1.1

package/dist/HttpClientResponse-D5ZKICVV.mjs

@@ -0,0 +1,855 @@
+import { Ct as NodeInspectSymbol, Et as format, Mt as redact, On as pipeArguments, S as none, St as Class, bn as dual, h as isNone, m as getOrUndefined, qt as hasProperty, u as fromNullishOr, w as some, xt as BaseProto } from "./Option-DkxSnBhp.mjs";
+import { B as flatMap, M as fail, Vt as runSync, Xt as succeed, cn as tryPromise, dt as map, f as cached, hi as currentTimeMillis$1, ia as Reference, li as ClockRef, ln as try_ } from "./Effect-CKFpqbmw.mjs";
+import { ot as try_$1, tt as isSuccess } from "./Array-B4kuTQeW.mjs";
+import { $n as set, Bn as set$1, Hn as fromBody, Kn as empty$3, Ln as empty$2, Qn as remove, Rn as fromInput, Vn as setAll$1, Wn as unwrap, cn as toCodecJson, er as setAll, nr as fromSetCookie, pt as fromJsonString, qn as fromInput$1, tt as decodeEffect, zn as redactUrl } from "./Schema-MiKt5K1v.mjs";
+import { i as TaggedError } from "./Data-CeCULr0-.mjs";
+import { S as fromReadableStream, f as fail$1 } from "./Stream-bK9QIETN.mjs";
+import { a as stringOrRedacted } from "./Redacted-RkJrG5Me.mjs";
+import { i as HttpClientError, n as EmptyBodyError, s as StatusCodeError, t as DecodeError } from "./HttpClientError-BUeMWx70.mjs";
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/Clock.js
+/**
+* Context reference for the active time service in the environment.
+*
+* **When to use**
+*
+* Use when you need to access or provide the full time service, including sleep
+* operations, rather than a single timestamp accessor.
+*
+* **Example** (Accessing the Clock service)
+*
+* ```ts import.meta.vitest
+* import { Clock, Effect } from "effect"
+*
+* const testClock: Clock.Clock = {
+*   currentTimeMillisUnsafe: () => 1_000,
+*   currentTimeMillis: Effect.succeed(1_000),
+*   monotonicTimeNanosUnsafe: () => 1_000_000_000n,
+*   monotonicTimeNanos: Effect.succeed(1_000_000_000n),
+*   currentTimeNanosUnsafe: () => 1_000_000_000n,
+*   currentTimeNanos: Effect.succeed(1_000_000_000n),
+*   sleep: () => Effect.void
+* }
+*
+* const program = Effect.gen(function*() {
+*   const clock = yield* Clock.Clock
+*   return clock.currentTimeMillisUnsafe()
+* })
+*
+* await Effect.runPromise(Effect.provideService(program, Clock.Clock, testClock)) // => 1_000
+* ```
+*
+* @see {@link clockWith} for using the current Clock service inside an effect
+* @see {@link currentTimeMillis} for reading the current time in milliseconds
+* @see {@link currentTimeNanos} for reading the current time in nanoseconds
+*
+* @stability stable
+* @category services
+* @since 2.0.0
+*/
+const Clock = ClockRef;
+/**
+* Returns an Effect that succeeds with the current Unix time in milliseconds.
+*
+* **When to use**
+*
+* Use to create wall-clock timestamps from the active `Clock` service with
+* millisecond precision.
+*
+* **Gotchas**
+*
+* The value can move backward or forward when the system wall clock is
+* corrected, so it is not suitable for measuring elapsed time.
+*
+* **Example** (Reading milliseconds)
+*
+* ```ts import.meta.vitest
+* import { Clock, Effect } from "effect"
+*
+* const testClock: Clock.Clock = {
+*   currentTimeMillisUnsafe: () => 1_000,
+*   currentTimeMillis: Effect.succeed(1_000),
+*   monotonicTimeNanosUnsafe: () => 1_000_000_000n,
+*   monotonicTimeNanos: Effect.succeed(1_000_000_000n),
+*   currentTimeNanosUnsafe: () => 1_000_000_000n,
+*   currentTimeNanos: Effect.succeed(1_000_000_000n),
+*   sleep: () => Effect.void
+* }
+*
+* await Effect.runPromise(Effect.provideService(Clock.currentTimeMillis, Clock.Clock, testClock)) // => 1_000
+* ```
+*
+* @see {@link currentTimeNanos} for nanosecond precision
+* @see {@link monotonicTimeNanos} for measuring elapsed time
+* @see {@link clockWith} for accessing the full Clock service
+*
+* @stability stable
+* @category accessors
+* @since 2.0.0
+*/
+const currentTimeMillis = currentTimeMillis$1;
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/http/HttpBody.js
+const TypeId$3 = "~effect/http/HttpBody";
+const HttpBodyErrorTypeId = "~effect/http/HttpBody/HttpBodyError";
+/**
+* Error produced while constructing an HTTP body from JSON or schema-encoded input.
+*
+* @stability unstable
+* @category errors
+* @since 4.0.0
+*/
+var HttpBodyError = class extends (/*#__PURE__*/ TaggedError("HttpBodyError")) {
+	/**
+	* Marks this value as an HTTP body error for runtime guards.
+	*
+	* @stability unstable
+	* @since 4.0.0
+	*/
+	[HttpBodyErrorTypeId] = HttpBodyErrorTypeId;
+};
+var Proto$1 = class {
+	[TypeId$3];
+	constructor() {
+		this[TypeId$3] = TypeId$3;
+	}
+	[NodeInspectSymbol]() {
+		return this.toJSON();
+	}
+	toString() {
+		return format(this, { ignoreToString: true });
+	}
+};
+/**
+* HTTP body variant representing the absence of request content.
+*
+* @stability unstable
+* @category models
+* @since 4.0.0
+*/
+var Empty = class extends Proto$1 {
+	_tag = "Empty";
+	toJSON() {
+		return {
+			_id: "effect/HttpBody",
+			_tag: "Empty"
+		};
+	}
+};
+/**
+* Provides the singleton empty HTTP body.
+*
+* **When to use**
+*
+* Use when you need an HTTP body value that represents no body content.
+*
+* @stability unstable
+* @category constants
+* @since 4.0.0
+*/
+const empty$1 = /*#__PURE__*/ new Empty();
+/**
+* HTTP body variant backed by a `Uint8Array`.
+*
+* **Details**
+*
+* It stores the bytes, content type, and byte length.
+*
+* @stability unstable
+* @category models
+* @since 4.0.0
+*/
+var Uint8Array = class extends Proto$1 {
+	_tag = "Uint8Array";
+	contentType;
+	contentLength;
+	/** Original text retained for adapters that can skip encoding. */
+	text;
+	_body;
+	constructor(body, contentType, contentLength, text) {
+		super();
+		this._body = body;
+		this.text = text;
+		this.contentType = contentType;
+		this.contentLength = contentLength;
+	}
+	get body() {
+		return this._body ??= encodeText(this.text);
+	}
+	toJSON() {
+		return {
+			_id: "effect/HttpBody",
+			_tag: "Uint8Array",
+			body: this.contentType.startsWith("text/") || this.contentType.endsWith("json") ? new TextDecoder().decode(this.body) : `Uint8Array(${this.body.length})`,
+			contentType: this.contentType,
+			contentLength: this.contentLength
+		};
+	}
+};
+/**
+* Creates a byte-array HTTP body.
+*
+* **Details**
+*
+* The content type defaults to `application/octet-stream`, and the content length is the byte array length.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const uint8Array = (body, contentType) => new Uint8Array(body, contentType ?? "application/octet-stream", body.length);
+const encoder = /*#__PURE__*/ new TextEncoder();
+const buffer = globalThis.Buffer;
+const encodeText = buffer !== void 0 ? (body) => buffer.from(body, "utf8") : (body) => encoder.encode(body);
+/**
+* Creates a UTF-8 encoded text HTTP body.
+*
+* **Details**
+*
+* The content type defaults to `text/plain`. Text bodies are encoded lazily.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const text = (body, contentType) => {
+	if (typeof body !== "string") body = body === void 0 ? "" : String(body);
+	if (buffer !== void 0) return new Uint8Array(void 0, contentType ?? "text/plain", buffer.byteLength(body, "utf8"), body);
+	const bytes = encoder.encode(body);
+	return new Uint8Array(bytes, contentType ?? "text/plain", bytes.length, body);
+};
+/**
+* Creates a JSON HTTP body using `JSON.stringify`, throwing if serialization fails.
+*
+* **Details**
+*
+* The content type defaults to `application/json`.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const jsonUnsafe = (body, contentType) => text(JSON.stringify(body), contentType ?? "application/json");
+/**
+* Creates a JSON HTTP body in an `Effect`.
+*
+* **Details**
+*
+* `JSON.stringify` failures are captured as `HttpBodyError` values, and the content type defaults to `application/json`.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const json = (body, contentType) => try_({
+	try: () => text(JSON.stringify(body), contentType ?? "application/json"),
+	catch: (cause) => new HttpBodyError({
+		reason: { _tag: "JsonError" },
+		cause
+	})
+});
+/**
+* HTTP body variant backed by a stream of `Uint8Array` chunks.
+*
+* @stability unstable
+* @category models
+* @since 4.0.0
+*/
+var Stream = class extends Proto$1 {
+	_tag = "Stream";
+	stream;
+	contentType;
+	contentLength;
+	constructor(stream, contentType, contentLength) {
+		super();
+		this.stream = stream;
+		this.contentType = contentType;
+		this.contentLength = contentLength;
+	}
+	toJSON() {
+		return {
+			_id: "effect/HttpBody",
+			_tag: "Stream",
+			contentType: this.contentType,
+			contentLength: this.contentLength
+		};
+	}
+};
+/**
+* Creates a streaming HTTP body from a stream of byte chunks.
+*
+* **Details**
+*
+* The content type defaults to `application/octet-stream`; content length is optional.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const stream = (body, contentType, contentLength) => new Stream(body, contentType ?? "application/octet-stream", contentLength);
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/http/internal/httpBody.js
+/**
+* @internal
+*/
+const updateHeaders = (headers, body) => {
+	if (body._tag === "Empty" || body._tag === "FormData") return remove(remove(headers, "content-type"), "content-length");
+	headers = body.contentType === void 0 ? remove(headers, "content-type") : set(headers, "content-type", body.contentType);
+	return updateContentLength(headers, body);
+};
+/**
+* @internal
+*/
+const updateContentLength = (headers, body) => {
+	const contentLength = body._tag === "Empty" || body._tag === "FormData" ? void 0 : body.contentLength;
+	return contentLength === void 0 ? remove(headers, "content-length") : set(headers, "content-length", contentLength.toString());
+};
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/http/Url.js
+/**
+* Error returned when constructing a `URL` fails.
+*
+* @stability unstable
+* @category errors
+* @since 4.0.0
+*/
+var UrlError = class extends (/*#__PURE__*/ TaggedError("UrlError")) {};
+/**
+* Creates a `URL` safely by appending `UrlParams` and an optional hash to a URL string.
+*
+* **Details**
+*
+* Returns a `Result` that fails with `UrlError` if the URL cannot be constructed.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const make$1 = (url, params, hash) => try_$1({
+	try: () => {
+		const urlInstance = new URL(url, baseUrl());
+		for (let i = 0; i < params.params.length; i++) {
+			const [key, value] = params.params[i];
+			if (value !== void 0) urlInstance.searchParams.append(key, unwrap(value));
+		}
+		if (hash !== void 0) urlInstance.hash = hash;
+		return urlInstance;
+	},
+	catch: (cause) => new UrlError({ cause })
+});
+const baseUrl = () => {
+	if ("location" in globalThis && globalThis.location !== void 0 && globalThis.location.origin !== void 0 && globalThis.location.pathname !== void 0) {
+		const base = location.origin + location.pathname;
+		try {
+			return new URL(base).href;
+		} catch {
+			return;
+		}
+	}
+};
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/http/HttpClientRequest.js
+const TypeId$2 = "~effect/http/HttpClientRequest";
+/**
+* Returns `true` when a value is an `HttpClientRequest`.
+*
+* @stability unstable
+* @category guards
+* @since 4.0.0
+*/
+const isHttpClientRequest = (u) => hasProperty(u, TypeId$2);
+const Proto = {
+	[TypeId$2]: TypeId$2,
+	...BaseProto,
+	toJSON() {
+		return {
+			_id: "HttpClientRequest",
+			method: this.method,
+			url: redactUrl(this.url),
+			urlParams: this.urlParams,
+			hash: this.hash,
+			headers: redact(this.headers),
+			body: this.body.toJSON()
+		};
+	},
+	pipe() {
+		return pipeArguments(this, arguments);
+	}
+};
+/**
+* Constructs an `HttpClientRequest` from fully normalized request components.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+function makeWith(method, url, urlParams, hash, headers, body) {
+	const self = Object.create(Proto);
+	self.method = method;
+	self.url = url;
+	self.urlParams = urlParams;
+	self.hash = hash;
+	self.headers = headers;
+	self.body = body;
+	return self;
+}
+/**
+* An empty `GET` request with no URL, query parameters, hash, headers, or body.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const empty = /*#__PURE__*/ makeWith("GET", "", empty$2, /*#__PURE__*/ none(), empty$3, empty$1);
+/**
+* Creates a request constructor for the specified HTTP method.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const make = (method) => (url, options) => modify(empty, {
+	method,
+	url,
+	...options ?? void 0
+});
+/**
+* Creates a `GET` request for the specified URL.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const get = /*#__PURE__*/ make("GET");
+/**
+* Creates a `POST` request for the specified URL.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const post = /*#__PURE__*/ make("POST");
+/**
+* Creates a `PATCH` request for the specified URL.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const patch = /*#__PURE__*/ make("PATCH");
+/**
+* Creates a `PUT` request for the specified URL.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const put = /*#__PURE__*/ make("PUT");
+const del = /*#__PURE__*/ make("DELETE");
+/**
+* Applies request options to an `HttpClientRequest`, returning a new request.
+*
+* @stability unstable
+* @category combinators
+* @since 4.0.0
+*/
+const modify = /*#__PURE__*/ dual(2, (self, options) => {
+	let result = self;
+	if (options.method) result = setMethod(result, options.method);
+	if (options.url) result = setUrl(result, options.url);
+	if (options.headers) result = setHeaders(result, options.headers);
+	if (options.urlParams) result = setUrlParams(result, options.urlParams);
+	if (options.hash) result = setHash(result, options.hash);
+	if (options.body) result = setBody(result, options.body);
+	if (options.accept) result = accept(result, options.accept);
+	if (options.acceptJson) result = acceptJson(result);
+	return result;
+});
+/**
+* Sets the HTTP method on a request, returning a new request.
+*
+* @stability unstable
+* @category combinators
+* @since 4.0.0
+*/
+const setMethod = /*#__PURE__*/ dual(2, (self, method) => makeWith(method, self.url, self.urlParams, self.hash, self.headers, self.body));
+/**
+* Sets a single request header, replacing any existing value for that header.
+*
+* @stability unstable
+* @category combinators
+* @since 4.0.0
+*/
+const setHeader = /*#__PURE__*/ dual(3, (self, key, value) => makeWith(self.method, self.url, self.urlParams, self.hash, set(self.headers, key, value), self.body));
+/**
+* Sets multiple request headers from an input collection, replacing existing values with matching names.
+*
+* @stability unstable
+* @category combinators
+* @since 4.0.0
+*/
+const setHeaders = /*#__PURE__*/ dual(2, (self, input) => makeWith(self.method, self.url, self.urlParams, self.hash, setAll(self.headers, input), self.body));
+/**
+* Sets the `Authorization` header using a bearer token.
+*
+* @stability unstable
+* @category combinators
+* @since 4.0.0
+*/
+const bearerToken = /*#__PURE__*/ dual(2, (self, token) => setHeader(self, "Authorization", `Bearer ${stringOrRedacted(token)}`));
+/**
+* Sets the `Accept` header to the specified media type.
+*
+* @stability unstable
+* @category combinators
+* @since 4.0.0
+*/
+const accept = /*#__PURE__*/ dual(2, (self, mediaType) => setHeader(self, "Accept", mediaType));
+/**
+* Sets the `Accept` header to `application/json`.
+*
+* @stability unstable
+* @category combinators
+* @since 4.0.0
+*/
+const acceptJson = /*#__PURE__*/ accept("application/json");
+/**
+* Sets the request URL. When given a `URL`, its search parameters and hash are extracted into the request's structured fields.
+*
+* @stability unstable
+* @category combinators
+* @since 4.0.0
+*/
+const setUrl = /*#__PURE__*/ dual(2, (self, url) => {
+	if (typeof url === "string") return makeWith(self.method, url, self.urlParams, self.hash, self.headers, self.body);
+	const clone = new URL(url.toString());
+	const urlParams = fromInput(clone.searchParams);
+	const hash = fromNullishOr(clone.hash === "" ? void 0 : clone.hash.slice(1));
+	clone.search = "";
+	clone.hash = "";
+	return makeWith(self.method, clone.toString(), urlParams, hash, self.headers, self.body);
+});
+/**
+* Prepends a URL segment to the request URL, inserting or trimming one slash as needed.
+*
+* @stability unstable
+* @category combinators
+* @since 4.0.0
+*/
+const prependUrl = /*#__PURE__*/ dual(2, (self, path) => {
+	if (path === "") return self;
+	return makeWith(self.method, joinSegments(path, self.url), self.urlParams, self.hash, self.headers, self.body);
+});
+const joinSegments = (first, second) => {
+	const endsWithSlash = first.endsWith("/");
+	const startsWithSlash = second.startsWith("/");
+	return endsWithSlash && startsWithSlash ? first + second.slice(1) : !endsWithSlash && !startsWithSlash ? first + "/" + second : first + second;
+};
+/**
+* Sets one query parameter, replacing existing values for that parameter name.
+*
+* **Details**
+*
+* A `Redacted` value is sent unwrapped and stays redacted in inspection, errors and spans.
+*
+* @stability unstable
+* @category combinators
+* @since 4.0.0
+*/
+const setUrlParam = /*#__PURE__*/ dual(3, (self, key, value) => makeWith(self.method, self.url, set$1(self.urlParams, key, value), self.hash, self.headers, self.body));
+/**
+* Sets query parameters from an input collection, replacing existing values for matching names.
+*
+* @stability unstable
+* @category combinators
+* @since 4.0.0
+*/
+const setUrlParams = /*#__PURE__*/ dual(2, (self, input) => makeWith(self.method, self.url, setAll$1(self.urlParams, input), self.hash, self.headers, self.body));
+/**
+* Sets the URL fragment on a request without the leading `#`.
+*
+* @stability unstable
+* @category combinators
+* @since 4.0.0
+*/
+const setHash = /*#__PURE__*/ dual(2, (self, hash) => makeWith(self.method, self.url, self.urlParams, some(hash), self.headers, self.body));
+/**
+* Sets the request body and updates `Content-Type` and `Content-Length` headers from the body metadata when available.
+*
+* @stability unstable
+* @category combinators
+* @since 4.0.0
+*/
+const setBody = /*#__PURE__*/ dual(2, (self, body) => {
+	return makeWith(self.method, self.url, self.urlParams, self.hash, updateHeaders(self.headers, body), body);
+});
+/**
+* Sets a `Uint8Array` request body with an optional content type.
+*
+* @stability unstable
+* @category combinators
+* @since 4.0.0
+*/
+const bodyUint8Array = /*#__PURE__*/ dual((args) => isHttpClientRequest(args[0]), (self, body, contentType) => setBody(self, uint8Array(body, contentType)));
+/**
+* Encodes a value as a JSON request body and sets it on the request, failing with `HttpBodyError` if encoding fails.
+*
+* @stability unstable
+* @category combinators
+* @since 4.0.0
+*/
+const bodyJson = /*#__PURE__*/ dual(2, (self, body) => map(json(body), (body) => setBody(self, body)));
+/**
+* Sets a JSON request body using unsafe JSON encoding.
+*
+* **When to use**
+*
+* Use when the request body is known to be JSON-serializable and a synchronous
+* `HttpClientRequest` result is needed.
+*
+* **Gotchas**
+*
+* JSON encoding may throw instead of failing in the Effect error channel.
+*
+* @stability unstable
+* @category combinators
+* @since 4.0.0
+*/
+const bodyJsonUnsafe = /*#__PURE__*/ dual(2, (self, body) => setBody(self, jsonUnsafe(body)));
+/**
+* Builds a `URL` from the request URL, query parameters, and hash, returning `Option.none()` if the URL is invalid.
+*
+* @stability unstable
+* @category combinators
+* @since 4.0.0
+*/
+function toUrl(self) {
+	const r = make$1(self.url, self.urlParams, getOrUndefined(self.hash));
+	if (isSuccess(r)) return some(r.success);
+	return none();
+}
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/http/HttpIncomingMessage.js
+/**
+* Type identifier for `HttpIncomingMessage` values.
+*
+* @stability unstable
+* @category type IDs
+* @since 4.0.0
+*/
+const TypeId$1 = "~effect/http/HttpIncomingMessage";
+/**
+* Creates a decoder that reads an incoming message's JSON body and decodes it with the supplied schema.
+*
+* @stability unstable
+* @category schemas
+* @since 4.0.0
+*/
+const schemaBodyJson = (schema, options) => {
+	const decode = decodeEffect(toCodecJson(schema));
+	const decodeJson = options?.reviver === void 0 ? void 0 : decodeEffect(fromJsonString(toCodecJson(schema), options));
+	return (self) => decodeJson === void 0 ? flatMap(self.json, (u) => decode(u, options)) : flatMap(self.text, (body) => body === "" ? flatMap(self.json, (u) => decode(u, options)) : decodeJson(body, options));
+};
+/**
+* Context reference for the optional maximum size allowed when reading an incoming message body.
+*
+* @stability unstable
+* @category references
+* @since 4.0.0
+*/
+const MaxBodySize = /*#__PURE__*/ Reference("effect/http/HttpIncomingMessage/MaxBodySize", { defaultValue: () => void 0 });
+/**
+* Builds an inspectable object for an incoming message and redacts headers.
+* The body is left unread.
+*
+* @stability unstable
+* @category converting
+* @since 4.0.0
+*/
+const inspect = (self, that) => {
+	return {
+		...that,
+		headers: redact(self.headers),
+		remoteAddress: self.remoteAddress
+	};
+};
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/http/internal/webResponse.js
+/**
+* Returns the original Web `Response` of a fetch-backed client response.
+* Wrappers forward it to the response they wrap.
+*
+* @internal
+*/
+const WebSourceSymbol = "~effect/http/HttpClientResponse/WebSource";
+/**
+* @internal
+*/
+const getWebSource = (self) => self[WebSourceSymbol]?.();
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/http/HttpClientResponse.js
+/**
+* Represents responses returned by the Effect HTTP client.
+*
+* An `HttpClientResponse` keeps the original request together with the response
+* status, headers, cookies, and body accessors from the shared incoming-message
+* model. This module includes constructors, schema-based decoders, helpers for
+* streaming response bodies, and utilities for matching or filtering by HTTP
+* status.
+*
+* @stability unstable
+* @since 4.0.0
+*/
+/**
+* Type identifier for `HttpClientResponse` values.
+*
+* @stability unstable
+* @category type IDs
+* @since 4.0.0
+*/
+const TypeId = "~effect/http/HttpClientResponse";
+/**
+* Wraps a Web `Response` and its original `HttpClientRequest` as an `HttpClientResponse`.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const fromWeb = (request, source) => new WebHttpClientResponse(request, source);
+/**
+* Pattern matches on a response status, checking exact status handlers before status-class handlers and `orElse`.
+*
+* @stability unstable
+* @category pattern matching
+* @since 4.0.0
+*/
+const matchStatus = /*#__PURE__*/ dual(2, (self, cases) => {
+	const status = self.status;
+	if (cases[status]) return cases[status](self);
+	else if (status >= 200 && status < 300 && cases["2xx"]) return cases["2xx"](self);
+	else if (status >= 300 && status < 400 && cases["3xx"]) return cases["3xx"](self);
+	else if (status >= 400 && status < 500 && cases["4xx"]) return cases["4xx"](self);
+	else if (status >= 500 && status < 600 && cases["5xx"]) return cases["5xx"](self);
+	return cases.orElse(self);
+});
+/**
+* Succeeds with the response only when its status is in the 2xx range, otherwise fails with `HttpClientError`.
+*
+* @stability unstable
+* @category filtering
+* @since 4.0.0
+*/
+const filterStatusOk = (self) => self.status >= 200 && self.status < 300 ? succeed(self) : fail(new HttpClientError({ reason: new StatusCodeError({
+	response: self,
+	request: self.request,
+	description: "non 2xx status code"
+}) }));
+var WebHttpClientResponse = class extends Class {
+	[TypeId$1];
+	[TypeId];
+	request;
+	source;
+	constructor(request, source) {
+		super();
+		this.request = request;
+		this.source = source;
+		this[TypeId$1] = TypeId$1;
+		this[TypeId] = TypeId;
+	}
+	toJSON() {
+		return inspect(this, {
+			_id: "HttpClientResponse",
+			request: this.request.toJSON(),
+			status: this.status
+		});
+	}
+	get status() {
+		return this.source.status;
+	}
+	get url() {
+		if (this.source.url) return this.source.url.split("#")[0];
+		const url = toUrl(this.request);
+		if (isNone(url)) return "";
+		url.value.hash = "";
+		return url.value.href;
+	}
+	get headers() {
+		return fromInput$1(this.source.headers);
+	}
+	cachedCookies;
+	get cookies() {
+		if (this.cachedCookies) return this.cachedCookies;
+		return this.cachedCookies = fromSetCookie(this.source.headers.getSetCookie?.() ?? []);
+	}
+	get remoteAddress() {
+		return none();
+	}
+	[WebSourceSymbol]() {
+		return this.source;
+	}
+	get stream() {
+		return this.source.body ? fromReadableStream({
+			evaluate: () => this.source.body,
+			onError: (cause) => new HttpClientError({ reason: new DecodeError({
+				request: this.request,
+				response: this,
+				cause
+			}) })
+		}) : fail$1(new HttpClientError({ reason: new EmptyBodyError({
+			request: this.request,
+			response: this,
+			description: "can not create stream from empty body"
+		}) }));
+	}
+	get json() {
+		return flatMap(this.text, (text) => try_({
+			try: () => text === "" ? null : JSON.parse(text),
+			catch: (cause) => new HttpClientError({ reason: new DecodeError({
+				request: this.request,
+				response: this,
+				cause
+			}) })
+		}));
+	}
+	textBody;
+	get text() {
+		return this.textBody ??= map(this.arrayBuffer, (_) => new TextDecoder().decode(_));
+	}
+	get urlParamsBody() {
+		return flatMap(this.arrayBuffer, (bytes) => try_({
+			try: () => fromInput(fromBody(bytes)),
+			catch: (cause) => new HttpClientError({ reason: new DecodeError({
+				request: this.request,
+				response: this,
+				cause
+			}) })
+		}));
+	}
+	formDataBody;
+	get formData() {
+		return this.formDataBody ??= tryPromise({
+			try: () => this.source.formData(),
+			catch: (cause) => new HttpClientError({ reason: new DecodeError({
+				request: this.request,
+				response: this,
+				cause
+			}) })
+		}).pipe(cached, runSync);
+	}
+	arrayBufferBody;
+	get arrayBuffer() {
+		if (this.arrayBufferBody) return this.arrayBufferBody;
+		this.arrayBufferBody = tryPromise({
+			try: () => this.source.arrayBuffer(),
+			catch: (cause) => new HttpClientError({ reason: new DecodeError({
+				request: this.request,
+				response: this,
+				cause
+			}) })
+		}).pipe(cached, runSync);
+		return this.arrayBufferBody;
+	}
+	get upgrade() {
+		return fail(new HttpClientError({ reason: new StatusCodeError({
+			request: this.request,
+			response: this,
+			description: "fetch cannot hand over the connection of an HTTP upgrade"
+		}) }));
+	}
+	pipe() {
+		return pipeArguments(this, arguments);
+	}
+};
+export { stream as A, put as C, toUrl as D, setUrlParams as E, uint8Array as M, Clock as N, make$1 as O, currentTimeMillis as P, prependUrl as S, setUrlParam as T, empty as _, WebSourceSymbol as a, patch as b, TypeId$1 as c, acceptJson as d, bearerToken as f, del as g, bodyUint8Array as h, matchStatus as i, text as j, empty$1 as k, inspect as l, bodyJsonUnsafe as m, filterStatusOk as n, getWebSource as o, bodyJson as p, fromWeb as r, MaxBodySize as s, TypeId as t, schemaBodyJson as u, get as v, setHeaders as w, post as x, make as y };