effect 4.0.5 → 4.0.6

package/src/http/HttpClient.ts

@@ -46,6 +46,7 @@ import * as HttpIncomingMessage from "./HttpIncomingMessage.ts"
 import * as HttpMethod from "./HttpMethod.ts"
 import * as TraceContext from "./HttpTraceContext.ts"
 import * as tracing from "./internal/tracing.ts"
+import { getWebSource, WebSourceSymbol } from "./internal/webResponse.ts"
 import * as Url from "./Url.ts"
 import * as UrlParams from "./UrlParams.ts"
 
@@ -467,56 +468,7 @@ export const catchTag: {
     transformResponse(
       self,
       (effect) =>
-        Effect.catchTag</**
-         * Handles client failures with one or more matching `_tag` values and returns a transformed client.
-         *
-         * @stability unstable
-         * @category error handling
-         * @since 4.0.0
-         */
-        HttpClientResponse.HttpClientResponse, /**
-         * Handles client failures with one or more matching `_tag` values and returns a transformed client.
-         *
-         * @stability unstable
-         * @category error handling
-         * @since 4.0.0
-         */
-        E, /**
-         * Handles client failures with one or more matching `_tag` values and returns a transformed client.
-         *
-         * @stability unstable
-         * @category error handling
-         * @since 4.0.0
-         */
-        R, /**
-         * Handles client failures with one or more matching `_tag` values and returns a transformed client.
-         *
-         * @stability unstable
-         * @category error handling
-         * @since 4.0.0
-         */
-        K, /**
-         * Handles client failures with one or more matching `_tag` values and returns a transformed client.
-         *
-         * @stability unstable
-         * @category error handling
-         * @since 4.0.0
-         */
-        R1, /**
-         * Handles client failures with one or more matching `_tag` values and returns a transformed client.
-         *
-         * @stability unstable
-         * @category error handling
-         * @since 4.0.0
-         */
-        E1, /**
-         * Handles client failures with one or more matching `_tag` values and returns a transformed client.
-         *
-         * @stability unstable
-         * @category error handling
-         * @since 4.0.0
-         */
-        HttpClientResponse.HttpClientResponse>(
+        Effect.catchTag<HttpClientResponse.HttpClientResponse, E, R, K, R1, E1, HttpClientResponse.HttpClientResponse>(
           effect,
           tag,
           f
@@ -1641,81 +1593,18 @@ export const withRateLimiter: {
     ) => {
       onResponse?.(clock, key, response.headers, tokens, sent)
       if (options.disableResponseInspection || response.status !== 429) {
-        return Effect.succeed</**
-         * Applies request rate limiting using the `RateLimiter` service.
-         *
-         * **Details**
-         *
-         * It can update limits by inspecting common rate limit response headers and
-         * automatically retries HTTP `429` responses (or `HttpClientError` values
-         * wrapping a `429` response) by forcing the retry back through the limiter.
-         * When a response reports the remaining budget, requests wait for the
-         * reported reset once that budget is exhausted.
-         *
-         * **Gotchas**
-         *
-         * Automatic HTTP `429` retries are unlimited unless `times` is specified.
-         * Disabling response inspection does not disable retries; set `times` to `0`
-         * to return or fail with the first `429`.
-         *
-         * @stability unstable
-         * @category rate limiting
-         * @since 4.0.0
-         */
-        Duration.Duration | undefined>(undefined);
+        return Effect.succeed<Duration.Duration | undefined>(undefined)
       }
       const retryAfter = parseRetryAfter(
         clock.currentTimeMillisUnsafe(),
         getHeader(response.headers, ...headerNames.retryAfter)
       )
       if (retryAfter === undefined) {
-        return Effect.succeed</**
-         * Applies request rate limiting using the `RateLimiter` service.
-         *
-         * **Details**
-         *
-         * It can update limits by inspecting common rate limit response headers and
-         * automatically retries HTTP `429` responses (or `HttpClientError` values
-         * wrapping a `429` response) by forcing the retry back through the limiter.
-         * When a response reports the remaining budget, requests wait for the
-         * reported reset once that budget is exhausted.
-         *
-         * **Gotchas**
-         *
-         * Automatic HTTP `429` retries are unlimited unless `times` is specified.
-         * Disabling response inspection does not disable retries; set `times` to `0`
-         * to return or fail with the first `429`.
-         *
-         * @stability unstable
-         * @category rate limiting
-         * @since 4.0.0
-         */
-        Duration.Duration | undefined>(undefined);
+        return Effect.succeed<Duration.Duration | undefined>(undefined)
       }
       const delay = parseRateLimitWindow(clock, response.headers, headerNames) ?? retryAfter
       if (adaptive === undefined) {
-        return Effect.succeed</**
-         * Applies request rate limiting using the `RateLimiter` service.
-         *
-         * **Details**
-         *
-         * It can update limits by inspecting common rate limit response headers and
-         * automatically retries HTTP `429` responses (or `HttpClientError` values
-         * wrapping a `429` response) by forcing the retry back through the limiter.
-         * When a response reports the remaining budget, requests wait for the
-         * reported reset once that budget is exhausted.
-         *
-         * **Gotchas**
-         *
-         * Automatic HTTP `429` retries are unlimited unless `times` is specified.
-         * Disabling response inspection does not disable retries; set `times` to `0`
-         * to return or fail with the first `429`.
-         *
-         * @stability unstable
-         * @category rate limiting
-         * @since 4.0.0
-         */
-        Duration.Duration | undefined>(delay);
+        return Effect.succeed<Duration.Duration | undefined>(delay)
       }
       return Effect.as(
         options.limiter.adaptiveFeedback({
@@ -1786,7 +1675,7 @@ export const withRateLimiter: {
         return Duration.isZero(delay) ? runAdaptive() : Effect.flatMap(Effect.sleep(delay), runAdaptive)
       }
     )
-  });
+  })
 })
 
 interface RateLimiterHeaderNames {
@@ -1888,6 +1777,8 @@ const parseRateLimitWindow = (
   return parseResetHeader(clock, getHeader(headers, ...headerNames.reset))
 }
 
+// An invalid Retry-After is treated as absent (RFC 9110 §10.2.3); the
+// one millisecond floor keeps a past date or `0` from retrying immediately.
 const parseRetryAfter = (
   nowMillis: number,
   value: string | undefined
@@ -1895,22 +1786,10 @@ const parseRetryAfter = (
   if (value === undefined) {
     return undefined
   }
-  const trimmed = value.trim()
-  if (/^\d+(?:\.\d+)?$/.test(trimmed)) {
-    const numeric = Number(trimmed)
-    return Number.isFinite(numeric)
-      ? Duration.max(Duration.seconds(numeric), Duration.millis(1))
-      : undefined
-  }
-  const parsedDate = Date.parse(trimmed)
-  if (Number.isNaN(parsedDate)) {
-    return undefined
-  }
-  const millis = parsedDate - nowMillis
-  if (millis <= 0) {
-    return Duration.millis(1)
-  }
-  return Duration.millis(millis)
+  const retryAfter = Headers.parseRetryAfter(value)
+  return Result.isSuccess(retryAfter)
+    ? Duration.max(Headers.retryAfterDelay(retryAfter.success, nowMillis), Duration.millis(1))
+    : undefined
 }
 
 const parseResetAfter = (value: string | undefined): Duration.Duration | undefined => {
@@ -2157,6 +2036,37 @@ export const withScope = <E, R>(
 /**
  * Enables following HTTP redirects up to a specified number of times.
  *
+ * **Details**
+ *
+ * Follows `3xx` responses that include a `Location` header, up to
+ * `maxRedirects` (default `10`) times. When the limit is reached or the
+ * `Location` header is not a valid URL, the last redirect response is returned.
+ *
+ * **Gotchas**
+ *
+ * This only sees redirects that the underlying client returns. `fetch`
+ * follows redirects itself by default, so with `FetchHttpClient` provide
+ * `FetchHttpClient.RequestInit` with `{ redirect: "manual" }`. Browsers return
+ * an opaque response without a `Location` header for manual redirects, so
+ * this cannot follow them there.
+ *
+ * **Example** (Following redirects with FetchHttpClient)
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ * import { FetchHttpClient, HttpClient } from "effect/http"
+ *
+ * const program = Effect.gen(function*() {
+ *   const client = (yield* HttpClient.HttpClient).pipe(
+ *     HttpClient.followRedirects(5)
+ *   )
+ *   return yield* client.get("https://example.com/redirect")
+ * }).pipe(
+ *   Effect.provide(FetchHttpClient.layer),
+ *   Effect.provideService(FetchHttpClient.RequestInit, { redirect: "manual" })
+ * )
+ * ```
+ *
  * @stability unstable
  * @category redirects
  * @since 4.0.0
@@ -2165,6 +2075,37 @@ export const followRedirects: {
   /**
    * Enables following HTTP redirects up to a specified number of times.
    *
+   * **Details**
+   *
+   * Follows `3xx` responses that include a `Location` header, up to
+   * `maxRedirects` (default `10`) times. When the limit is reached or the
+   * `Location` header is not a valid URL, the last redirect response is returned.
+   *
+   * **Gotchas**
+   *
+   * This only sees redirects that the underlying client returns. `fetch`
+   * follows redirects itself by default, so with `FetchHttpClient` provide
+   * `FetchHttpClient.RequestInit` with `{ redirect: "manual" }`. Browsers return
+   * an opaque response without a `Location` header for manual redirects, so
+   * this cannot follow them there.
+   *
+   * **Example** (Following redirects with FetchHttpClient)
+   *
+   * ```ts
+   * import { Effect } from "effect"
+   * import { FetchHttpClient, HttpClient } from "effect/http"
+   *
+   * const program = Effect.gen(function*() {
+   *   const client = (yield* HttpClient.HttpClient).pipe(
+   *     HttpClient.followRedirects(5)
+   *   )
+   *   return yield* client.get("https://example.com/redirect")
+   * }).pipe(
+   *   Effect.provide(FetchHttpClient.layer),
+   *   Effect.provideService(FetchHttpClient.RequestInit, { redirect: "manual" })
+   * )
+   * ```
+   *
    * @stability unstable
    * @category redirects
    * @since 4.0.0
@@ -2173,6 +2114,37 @@ export const followRedirects: {
   /**
    * Enables following HTTP redirects up to a specified number of times.
    *
+   * **Details**
+   *
+   * Follows `3xx` responses that include a `Location` header, up to
+   * `maxRedirects` (default `10`) times. When the limit is reached or the
+   * `Location` header is not a valid URL, the last redirect response is returned.
+   *
+   * **Gotchas**
+   *
+   * This only sees redirects that the underlying client returns. `fetch`
+   * follows redirects itself by default, so with `FetchHttpClient` provide
+   * `FetchHttpClient.RequestInit` with `{ redirect: "manual" }`. Browsers return
+   * an opaque response without a `Location` header for manual redirects, so
+   * this cannot follow them there.
+   *
+   * **Example** (Following redirects with FetchHttpClient)
+   *
+   * ```ts
+   * import { Effect } from "effect"
+   * import { FetchHttpClient, HttpClient } from "effect/http"
+   *
+   * const program = Effect.gen(function*() {
+   *   const client = (yield* HttpClient.HttpClient).pipe(
+   *     HttpClient.followRedirects(5)
+   *   )
+   *   return yield* client.get("https://example.com/redirect")
+   * }).pipe(
+   *   Effect.provide(FetchHttpClient.layer),
+   *   Effect.provideService(FetchHttpClient.RequestInit, { redirect: "manual" })
+   * )
+   * ```
+   *
    * @stability unstable
    * @category redirects
    * @since 4.0.0
@@ -2202,7 +2174,11 @@ export const followRedirects: {
               ) {
                 return Effect.succeed(response)
               }
-              const url = new URL(response.headers.location, response.request.url)
+              const urlResult = Url.fromString(response.headers.location, response.request.url)
+              if (Result.isFailure(urlResult)) {
+                return Effect.succeed(response)
+              }
+              const url = urlResult.success
               const request = currentRequest ?? response.request
               let nextRequest = request
               if (
@@ -2324,7 +2300,11 @@ export const layerMergedContext = <E, R>(
 const responseRegistry = (() => {
   if ("FinalizationRegistry" in globalThis && globalThis.FinalizationRegistry) {
     const registry = new FinalizationRegistry((controller: AbortController) => {
-      controller.abort()
+      try {
+        controller.abort()
+      } catch {
+        // Runtimes such as workerd disallow aborting I/O outside its request context.
+      }
     })
     return {
       register(response: HttpClientResponse.HttpClientResponse, controller: AbortController) {
@@ -2424,6 +2404,17 @@ class InterruptibleResponse implements HttpClientResponse.HttpClientResponse, Pi
     return this.applyInterrupt(this.original.arrayBuffer)
   }
 
+  get upgrade() {
+    return this.applyInterrupt(this.original.upgrade)
+  }
+
+  [WebSourceSymbol]() {
+    const source = getWebSource(this.original)
+    // A handed-over Web body outlives this wrapper, so collecting it must not abort the request.
+    if (source !== undefined) responseRegistry.unregister(this.original)
+    return source
+  }
+
   get stream() {
     return Stream.suspend(() => {
       responseRegistry.unregister(this.original)

package/src/http/HttpClientRequest.ts

@@ -13,6 +13,7 @@
 import type * as ByteSize from "../ByteSize.ts"
 import * as Context from "../Context.ts"
 import * as Effect from "../Effect.ts"
+import * as Base64 from "../encoding/Base64.ts"
 import type * as FileSystem from "../FileSystem.ts"
 import { dual } from "../Function.ts"
 import * as Inspectable from "../Inspectable.ts"
@@ -483,7 +484,8 @@ export const removeHeader: {
 )
 
 /**
- * Sets the `Authorization` header using HTTP Basic authentication credentials.
+ * Sets the `Authorization` header using HTTP Basic authentication credentials,
+ * encoded as UTF-8 before base64 encoding.
  *
  * @stability unstable
  * @category combinators
@@ -491,7 +493,8 @@ export const removeHeader: {
  */
 export const basicAuth: {
   /**
-   * Sets the `Authorization` header using HTTP Basic authentication credentials.
+   * Sets the `Authorization` header using HTTP Basic authentication credentials,
+   * encoded as UTF-8 before base64 encoding.
    *
    * @stability unstable
    * @category combinators
@@ -499,7 +502,8 @@ export const basicAuth: {
    */
   (username: string | Redacted.Redacted, password: string | Redacted.Redacted): (self: HttpClientRequest) => HttpClientRequest
   /**
-   * Sets the `Authorization` header using HTTP Basic authentication credentials.
+   * Sets the `Authorization` header using HTTP Basic authentication credentials,
+   * encoded as UTF-8 before base64 encoding.
    *
    * @stability unstable
    * @category combinators
@@ -517,7 +521,11 @@ export const basicAuth: {
     username: string | Redacted.Redacted,
     password: string | Redacted.Redacted
   ): HttpClientRequest =>
-    setHeader(self, "Authorization", `Basic ${btoa(`${stringOrRedacted(username)}:${stringOrRedacted(password)}`)}`)
+    setHeader(
+      self,
+      "Authorization",
+      `Basic ${Base64.encode(`${stringOrRedacted(username)}:${stringOrRedacted(password)}`)}`
+    )
 )
 
 /**
@@ -585,6 +593,136 @@ export const accept: {
  */
 export const acceptJson: (self: HttpClientRequest) => HttpClientRequest = accept("application/json")
 
+/**
+ * Asks the server to switch the connection to another protocol by setting the
+ * `Connection: Upgrade` and `Upgrade` headers.
+ *
+ * **When to use**
+ *
+ * Use to switch an HTTP/1.1 connection to a raw byte stream, such as Docker's
+ * `Upgrade: tcp` for container attach. For WebSocket, use `Socket.makeWebSocket`.
+ *
+ * **Details**
+ *
+ * The request is otherwise ordinary, so client transforms such as base URLs,
+ * authentication, and tracing apply to it. When the server answers `101
+ * Switching Protocols`, `HttpClientResponse.upgrade` hands over the
+ * connection as a `Socket`. Any other response is read as usual.
+ *
+ * **Example** (Attaching to a Docker container)
+ *
+ * ```ts
+ * import { Effect } from "effect"
+ * import { HttpClient, HttpClientRequest } from "effect/http"
+ *
+ * const program = Effect.gen(function*() {
+ *   const client = yield* HttpClient.HttpClient
+ *   const response = yield* client.execute(
+ *     HttpClientRequest.post("/containers/abc/attach?stream=1&stdout=1").pipe(
+ *       HttpClientRequest.upgrade("tcp")
+ *     )
+ *   )
+ *   const socket = yield* response.upgrade
+ *   const reader = yield* socket.reader
+ *   return yield* reader.pull
+ * })
+ * ```
+ *
+ * @stability unstable
+ * @category combinators
+ * @since 4.0.6
+ */
+export const upgrade: {
+  /**
+   * Asks the server to switch the connection to another protocol by setting the
+   * `Connection: Upgrade` and `Upgrade` headers.
+   *
+   * **When to use**
+   *
+   * Use to switch an HTTP/1.1 connection to a raw byte stream, such as Docker's
+   * `Upgrade: tcp` for container attach. For WebSocket, use `Socket.makeWebSocket`.
+   *
+   * **Details**
+   *
+   * The request is otherwise ordinary, so client transforms such as base URLs,
+   * authentication, and tracing apply to it. When the server answers `101
+   * Switching Protocols`, `HttpClientResponse.upgrade` hands over the
+   * connection as a `Socket`. Any other response is read as usual.
+   *
+   * **Example** (Attaching to a Docker container)
+   *
+   * ```ts
+   * import { Effect } from "effect"
+   * import { HttpClient, HttpClientRequest } from "effect/http"
+   *
+   * const program = Effect.gen(function*() {
+   *   const client = yield* HttpClient.HttpClient
+   *   const response = yield* client.execute(
+   *     HttpClientRequest.post("/containers/abc/attach?stream=1&stdout=1").pipe(
+   *       HttpClientRequest.upgrade("tcp")
+   *     )
+   *   )
+   *   const socket = yield* response.upgrade
+   *   const reader = yield* socket.reader
+   *   return yield* reader.pull
+   * })
+   * ```
+   *
+   * @stability unstable
+   * @category combinators
+   * @since 4.0.6
+   */
+  (protocol: string): (self: HttpClientRequest) => HttpClientRequest
+  /**
+   * Asks the server to switch the connection to another protocol by setting the
+   * `Connection: Upgrade` and `Upgrade` headers.
+   *
+   * **When to use**
+   *
+   * Use to switch an HTTP/1.1 connection to a raw byte stream, such as Docker's
+   * `Upgrade: tcp` for container attach. For WebSocket, use `Socket.makeWebSocket`.
+   *
+   * **Details**
+   *
+   * The request is otherwise ordinary, so client transforms such as base URLs,
+   * authentication, and tracing apply to it. When the server answers `101
+   * Switching Protocols`, `HttpClientResponse.upgrade` hands over the
+   * connection as a `Socket`. Any other response is read as usual.
+   *
+   * **Example** (Attaching to a Docker container)
+   *
+   * ```ts
+   * import { Effect } from "effect"
+   * import { HttpClient, HttpClientRequest } from "effect/http"
+   *
+   * const program = Effect.gen(function*() {
+   *   const client = yield* HttpClient.HttpClient
+   *   const response = yield* client.execute(
+   *     HttpClientRequest.post("/containers/abc/attach?stream=1&stdout=1").pipe(
+   *       HttpClientRequest.upgrade("tcp")
+   *     )
+   *   )
+   *   const socket = yield* response.upgrade
+   *   const reader = yield* socket.reader
+   *   return yield* reader.pull
+   * })
+   * ```
+   *
+   * @stability unstable
+   * @category combinators
+   * @since 4.0.6
+   */
+  (self: HttpClientRequest, protocol: string): HttpClientRequest
+} = dual(2, (self: HttpClientRequest, protocol: string): HttpClientRequest =>
+  makeWith(
+    self.method,
+    self.url,
+    self.urlParams,
+    self.hash,
+    Headers.set(Headers.set(self.headers, "connection", "Upgrade"), "upgrade", protocol),
+    self.body
+  ))
+
 /**
  * Sets the request URL. When given a `URL`, its search parameters and hash are extracted into the request's structured fields.
  *

package/src/http/HttpClientResponse.ts

@@ -17,6 +17,7 @@ import * as Option from "../Option.ts"
 import { type Pipeable, pipeArguments } from "../Pipeable.ts"
 import * as Schema from "../Schema.ts"
 import type { ParseOptions } from "../SchemaAST.ts"
+import type * as Socket from "../socket/Socket.ts"
 import * as Stream from "../Stream.ts"
 import type { Unify } from "../Unify.ts"
 import * as Cookies from "./Cookies.ts"
@@ -24,6 +25,7 @@ import * as Headers from "./Headers.ts"
 import * as Error from "./HttpClientError.ts"
 import * as HttpClientRequest from "./HttpClientRequest.ts"
 import * as HttpIncomingMessage from "./HttpIncomingMessage.ts"
+import { getWebSource, WebSourceSymbol } from "./internal/webResponse.ts"
 import * as UrlParams from "./UrlParams.ts"
 
 /**
@@ -83,6 +85,23 @@ export interface HttpClientResponse extends HttpIncomingMessage.HttpIncomingMess
   readonly status: number
   readonly cookies: Cookies.Cookies
   readonly formData: Effect.Effect<FormData, Error.HttpClientError>
+  /**
+   * Hands over the connection of a `101 Switching Protocols` response as a
+   * `Socket`.
+   *
+   * **Details**
+   *
+   * Ask for an upgrade with `HttpClientRequest.upgrade`. Bytes the server
+   * sent after the response head come first on the reader. Releasing the
+   * writer's scope half-closes the connection, and releasing the reader's
+   * scope closes it. Closing the request's scope (see `HttpClient.withScope`)
+   * also closes it.
+   *
+   * Fails with a `StatusCodeError` for any other status, so a refusal can be
+   * read from the response body as usual. Backends that cannot hand over a
+   * connection, such as fetch, never produce a `101` and fail the same way.
+   */
+  readonly upgrade: Effect.Effect<Socket.Socket, Error.HttpClientError>
 }
 
 /**
@@ -95,6 +114,42 @@ export interface HttpClientResponse extends HttpIncomingMessage.HttpIncomingMess
 export const fromWeb = (request: HttpClientRequest.HttpClientRequest, source: Response): HttpClientResponse =>
   new WebHttpClientResponse(request, source)
 
+/**
+ * Returns the original Web `Response` of a fetch-backed `HttpClientResponse`.
+ *
+ * **When to use**
+ *
+ * Use to hand a response body to a Web API without copying it, such as
+ * writing a fetched file to Cloudflare R2. The original body keeps runtime
+ * capabilities, such as workerd's known length, that a stream converted from
+ * `stream` does not.
+ *
+ * **Details**
+ *
+ * Returns `Some` for responses created with `fromWeb`, which includes every
+ * response from `FetchHttpClient`, and `None` for other backends.
+ *
+ * Calling `toWeb` hands the body over: the response is no longer aborted when
+ * the `HttpClientResponse` is garbage collected, so read or cancel the body
+ * through the returned `Response`.
+ *
+ * **Gotchas**
+ *
+ * The body can be read once. After converting, read it from the returned
+ * `Response`, not from the `HttpClientResponse`.
+ *
+ * After the hand-off, Effect aborts the request only when the scope of
+ * `HttpClient.withScope` closes. When the request streams its body, finishing
+ * or cancelling the returned body does not stop the upload; execute the
+ * request with `HttpClient.withScope` and close the scope to stop it.
+ *
+ * @stability unstable
+ * @category converting
+ * @since 4.0.0
+ */
+export const toWeb = (self: HttpClientResponse): Option.Option<globalThis.Response> =>
+  Option.fromUndefinedOr(getWebSource(self))
+
 /**
  * Creates a decoder for a response's status, headers, and JSON body using the supplied schema.
  *
@@ -350,6 +405,10 @@ class WebHttpClientResponse extends Inspectable.Class implements HttpClientRespo
     return Option.none()
   }
 
+  [WebSourceSymbol](): globalThis.Response {
+    return this.source
+  }
+
   get stream(): Stream.Stream<Uint8Array, Error.HttpClientError> {
     return this.source.body
       ? Stream.fromReadableStream({
@@ -443,6 +502,18 @@ class WebHttpClientResponse extends Inspectable.Class implements HttpClientRespo
     return this.arrayBufferBody
   }
 
+  get upgrade(): Effect.Effect<Socket.Socket, Error.HttpClientError> {
+    return Effect.fail(
+      new Error.HttpClientError({
+        reason: new Error.StatusCodeError({
+          request: this.request,
+          response: this,
+          description: "fetch cannot hand over the connection of an HTTP upgrade"
+        })
+      })
+    )
+  }
+
   pipe() {
     return pipeArguments(this, arguments)
   }