effect 4.0.3 → 4.0.4

package/src/graphql/index.ts

@@ -0,0 +1,48 @@
+/**
+ * @stability experimental
+ * @since 4.0.0
+ */
+
+// @barrel: Auto-generated exports. Do not edit manually.
+
+/**
+ * @stability experimental
+ * @since 4.0.0
+ */
+export * as GraphQL from "./GraphQL.ts"
+
+/**
+ * @stability experimental
+ * @since 4.0.0
+ */
+export * as GraphQLClient from "./GraphQLClient.ts"
+
+/**
+ * @stability experimental
+ * @since 4.0.0
+ */
+export * as GraphQLClientError from "./GraphQLClientError.ts"
+
+/**
+ * @stability experimental
+ * @since 4.0.0
+ */
+export * as GraphQLGroup from "./GraphQLGroup.ts"
+
+/**
+ * @stability experimental
+ * @since 4.0.0
+ */
+export * as GraphQLMiddleware from "./GraphQLMiddleware.ts"
+
+/**
+ * @stability experimental
+ * @since 4.0.0
+ */
+export * as GraphQLProtocol from "./GraphQLProtocol.ts"
+
+/**
+ * @stability experimental
+ * @since 4.0.0
+ */
+export * as GraphQLResolver from "./GraphQLResolver.ts"

package/src/http/HttpClient.ts

@@ -1204,6 +1204,9 @@ export const retry: {
  * Specifying a `while` predicate allows you to consider other errors as
  * transient, and is ignored in "response-only" mode.
  *
+ * A `Retry-After` header on a transient response, or on the response of a
+ * status code error, sets the minimum delay before the next attempt.
+ *
  * @stability unstable
  * @category error handling
  * @since 4.0.0
@@ -1221,6 +1224,9 @@ export const retryTransient: {
    * Specifying a `while` predicate allows you to consider other errors as
    * transient, and is ignored in "response-only" mode.
    *
+   * A `Retry-After` header on a transient response, or on the response of a
+   * status code error, sets the minimum delay before the next attempt.
+   *
    * @stability unstable
    * @category error handling
    * @since 4.0.0
@@ -1257,6 +1263,9 @@ export const retryTransient: {
    * Specifying a `while` predicate allows you to consider other errors as
    * transient, and is ignored in "response-only" mode.
    *
+   * A `Retry-After` header on a transient response, or on the response of a
+   * status code error, sets the minimum delay before the next attempt.
+   *
    * @stability unstable
    * @category error handling
    * @since 4.0.0
@@ -1295,6 +1304,9 @@ export const retryTransient: {
    * Specifying a `while` predicate allows you to consider other errors as
    * transient, and is ignored in "response-only" mode.
    *
+   * A `Retry-After` header on a transient response, or on the response of a
+   * status code error, sets the minimum delay before the next attempt.
+   *
    * @stability unstable
    * @category error handling
    * @since 4.0.0
@@ -1314,6 +1326,9 @@ export const retryTransient: {
    * Specifying a `while` predicate allows you to consider other errors as
    * transient, and is ignored in "response-only" mode.
    *
+   * A `Retry-After` header on a transient response, or on the response of a
+   * status code error, sets the minimum delay before the next attempt.
+   *
    * @stability unstable
    * @category error handling
    * @since 4.0.0
@@ -1341,14 +1356,15 @@ export const retryTransient: {
   ): HttpClient.With<E | ES, R1 | R> => {
     const isOnlySchedule = Schedule.isSchedule(options)
     const retryOn = isOnlySchedule ? "errors-and-responses" : options.retryOn ?? "errors-and-responses"
-    const schedule = isOnlySchedule ? options : options.schedule
-    const passthroughSchedule = schedule && Schedule.passthrough(schedule)
+    const schedule = withRetryAfter(
+      isOnlySchedule ? options : options.schedule ?? Schedule.forever
+    )
     const times = isOnlySchedule ? undefined : options.times
     return transformResponse(
       self,
       flow(
         retryOn === "errors-only" ? identity : Effect.repeat({
-          schedule: passthroughSchedule!,
+          schedule,
           times,
           while: isTransientResponse
         }),
@@ -1643,7 +1659,10 @@ export const withRateLimiter: {
          */
         Duration.Duration | undefined>(undefined);
       }
-      const retryAfter = parseRetryAfter(clock, getHeader(response.headers, ...headerNames.retryAfter))
+      const retryAfter = parseRetryAfter(
+        clock.currentTimeMillisUnsafe(),
+        getHeader(response.headers, ...headerNames.retryAfter)
+      )
       if (retryAfter === undefined) {
         return Effect.succeed</**
          * Applies request rate limiting using the `RateLimiter` service.
@@ -1865,21 +1884,24 @@ const parseRateLimitWindow = (
 }
 
 const parseRetryAfter = (
-  clock: Clock,
+  nowMillis: number,
   value: string | undefined
 ): Duration.Duration | undefined => {
   if (value === undefined) {
     return undefined
   }
-  const numeric = parseNumberHeader(value)
-  if (numeric !== undefined) {
-    return Duration.max(Duration.seconds(numeric), Duration.millis(1))
+  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(value)
+  const parsedDate = Date.parse(trimmed)
   if (Number.isNaN(parsedDate)) {
     return undefined
   }
-  const millis = parsedDate - clock.currentTimeMillisUnsafe()
+  const millis = parsedDate - nowMillis
   if (millis <= 0) {
     return Duration.millis(1)
   }
@@ -2417,6 +2439,28 @@ const isTransientHttpError = (error: unknown) =>
   (error.reason._tag === "TransportError" ||
     (error.reason._tag === "StatusCodeError" && isTransientResponse(error.reason.response)))
 
+const retryAfterOf = (input: unknown, nowMillis: number): Duration.Duration | undefined => {
+  const response = Error.isHttpClientError(input)
+    ? input.response
+    : Predicate.hasProperty(input, HttpClientResponse.TypeId)
+    ? input as HttpClientResponse.HttpClientResponse
+    : undefined
+  return parseRetryAfter(nowMillis, response?.headers["retry-after"])
+}
+
+const withRetryAfter = <ES, R1>(
+  schedule: Schedule.Schedule<unknown, any, ES, R1>
+): Schedule.Schedule<unknown, any, ES, R1> =>
+  Schedule.fromStep(
+    Effect.map(Schedule.toStep(schedule), (step) => (now: number, input: unknown) => {
+      const retryAfter = retryAfterOf(input, now)
+      if (retryAfter === undefined) {
+        return step(now, input)
+      }
+      return Effect.map(step(now, input), ([output, delay]) => [output, Duration.max(delay, retryAfter)])
+    })
+  )
+
 const isTooManyRequestsHttpClientError = (
   error: unknown
 ): error is Error.HttpClientError & { readonly reason: Error.StatusCodeError } =>

package/src/http/HttpEffect.ts

@@ -347,10 +347,11 @@ export const toWebHandlerWith = <Provided, R = never, ReqR = Exclude<R, Provided
   const httpApp = toHandled(self, (request, response) => {
     const withoutBody = request.method === "HEAD"
     if (!Response.omitsBody(response, withoutBody)) {
+      // The transferred request scope closes when an abort interrupts the body, even if it is no longer read.
       response = scopeTransferToStream(response)
     }
     ;(request as any)[resolveSymbol](
-      Response.toWeb(response, { withoutBody, context })
+      Response.toWeb(response, { withoutBody, context, signal: (request.source as globalThis.Request).signal })
     )
     return Effect.void
   }, middleware)
@@ -366,10 +367,15 @@ export const toWebHandlerWith = <Provided, R = never, ReqR = Exclude<R, Provided
       reqContext = Context.add(reqContext, HttpServerRequest, httpServerRequest)
       ;(httpServerRequest as any)[resolveSymbol] = resolve
       const fiber = Effect.runForkWith(reqContext)(httpApp as any)
-      if (fiber.pollUnsafe() === undefined) {
-        request.signal?.addEventListener("abort", () => {
-          fiber.interruptUnsafe(undefined, ClientAbort.annotation)
-        }, { once: true })
+      const signal = request.signal
+      if (fiber.pollUnsafe() === undefined && signal) {
+        const onAbort = () => fiber.interruptUnsafe(undefined, ClientAbort.annotation)
+        if (signal.aborted) {
+          onAbort()
+        } else {
+          signal.addEventListener("abort", onAbort, { once: true })
+          fiber.addObserver(() => signal.removeEventListener("abort", onAbort))
+        }
       }
     })
 }

package/src/http/HttpMiddleware.ts

@@ -268,42 +268,41 @@ export const tracer: <E, R>(
       }
       const redactedHeaderNames = fiber.getRef(Headers.CurrentRedactedNames)
       const headerFilter = fiber.getRef(TracerHeaderFilter)
-      fiber.currentDispatcher.scheduleTask(() => {
-        let response: HttpServerResponse
-        let spanExit: Exit.Exit<HttpServerResponse, unknown>
-        if (Exit.isFailure(exit)) {
-          const [failureResponse, cause] = causeResponseStripped(exit.cause)
-          response = failureResponse
-          // OpenTelemetry only treats 5xx responses as server span errors; interrupts still fail the span.
-          spanExit = Option.isSome(cause) && (response.status >= 500 || Cause.hasInterrupts(cause.value))
-            ? Exit.failCause(cause.value)
-            : responseSpanExit(request, response)
-        } else {
-          response = exit.value
-          spanExit = responseSpanExit(request, response)
-        }
-        if (span.sampled) {
-          span.attribute("http.request.method", request.method)
-          const url = Request.toURL(request)
-          if (Option.isSome(url)) {
-            if (!request.url.startsWith("/") && (url.value.username !== "" || url.value.password !== "")) {
-              url.value.username = "REDACTED"
-              url.value.password = "REDACTED"
-            }
-            tracing.addUrlAttributes(span, url.value)
-          }
-          if (request.headers["user-agent"] !== undefined) {
-            span.attribute("user_agent.original", request.headers["user-agent"])
-          }
-          tracing.addHeaderAttributes(span, "request", request.headers, headerFilter, redactedHeaderNames)
-          if (Option.isSome(request.remoteAddress)) {
-            span.attribute("client.address", request.remoteAddress.value)
+      // Complete the span before the request fiber exits so shutdown can flush it.
+      let response: HttpServerResponse
+      let spanExit: Exit.Exit<HttpServerResponse, unknown>
+      if (Exit.isFailure(exit)) {
+        const [failureResponse, cause] = causeResponseStripped(exit.cause)
+        response = failureResponse
+        // OpenTelemetry only treats 5xx responses as server span errors; interrupts still fail the span.
+        spanExit = Option.isSome(cause) && (response.status >= 500 || Cause.hasInterrupts(cause.value))
+          ? Exit.failCause(cause.value)
+          : responseSpanExit(request, response)
+      } else {
+        response = exit.value
+        spanExit = responseSpanExit(request, response)
+      }
+      if (span.sampled) {
+        span.attribute("http.request.method", request.method)
+        const url = Request.toURL(request)
+        if (Option.isSome(url)) {
+          if (!request.url.startsWith("/") && (url.value.username !== "" || url.value.password !== "")) {
+            url.value.username = "REDACTED"
+            url.value.password = "REDACTED"
           }
-          span.attribute("http.response.status_code", response.status)
-          tracing.addHeaderAttributes(span, "response", response.headers, headerFilter, redactedHeaderNames)
+          tracing.addUrlAttributes(span, url.value)
         }
-        span.end(endTime, spanExit)
-      }, 0)
+        if (request.headers["user-agent"] !== undefined) {
+          span.attribute("user_agent.original", request.headers["user-agent"])
+        }
+        tracing.addHeaderAttributes(span, "request", request.headers, headerFilter, redactedHeaderNames)
+        if (Option.isSome(request.remoteAddress)) {
+          span.attribute("client.address", request.remoteAddress.value)
+        }
+        span.attribute("http.response.status_code", response.status)
+        tracing.addHeaderAttributes(span, "response", response.headers, headerFilter, redactedHeaderNames)
+      }
+      span.end(endTime, spanExit)
       return undefined
     })
     return httpApp

package/src/http/HttpRouter.ts

@@ -1410,6 +1410,41 @@ export const serve = <A, E, R, HE, HR = Request.Only<"Requires", R> | Request.On
  * request arrives, in which case that request waits for the build to finish.
  * If the build fails, every request rejects with the build error.
  *
+ * **Gotchas**
+ *
+ * On Cloudflare Workers, build the handler at module scope: fibers started
+ * inside `fetch` capture that request's async context. Layer construction
+ * must not require request-time I/O; bindings are available from
+ * `cloudflare:workers` via its `env` export.
+ * Prefer request-local work or a Durable Object's supported lifecycle APIs,
+ * not indefinite background execution. For shared fibers, provide a sync
+ * scheduler to both layers and requests as below; see `Scheduler.MixedScheduler`
+ * for its limitations. Bound waits for shared work with request-local timeouts.
+ *
+ * **Example** (Opting in to the sync scheduler on Workers)
+ *
+ * ```ts
+ * import { Effect, Layer, Scheduler } from "effect"
+ * import { HttpRouter, HttpServer, HttpServerResponse } from "effect/http"
+ *
+ * const SyncScheduler = Layer.succeed(
+ *   Scheduler.Scheduler,
+ *   new Scheduler.MixedScheduler("sync")
+ * )
+ * const AppLive = HttpRouter.add(
+ *   "GET",
+ *   "/ping",
+ *   Effect.succeed(HttpServerResponse.text("pong"))
+ * ).pipe(Layer.provide(HttpServer.layerServices))
+ *
+ * // Build once at module scope. The scheduler is also retained for requests.
+ * const app = HttpRouter.toWebHandler(
+ *   AppLive.pipe(Layer.provideMerge(SyncScheduler))
+ * )
+ *
+ * export default { fetch: (request: Request) => app.handler(request) }
+ * ```
+ *
  * @stability unstable
  * @category converting
  * @since 4.0.0

package/src/http/HttpServerResponse.ts

@@ -1346,23 +1346,35 @@ export const setStatus: {
 export const omitsBody = (response: HttpServerResponse, withoutBody = false): boolean =>
   withoutBody || response.status === 204 || response.status === 205 || response.status === 304
 
+const mergeHeaders = (target: globalThis.Headers, headers: globalThis.Headers): globalThis.Headers => {
+  for (const [key, value] of headers as any) {
+    if (key === "set-cookie") {
+      target.append(key, value)
+    } else {
+      target.set(key, value)
+    }
+  }
+  return target
+}
+
 /**
  * Converts an `HttpServerResponse` to a Web `Response`.
  *
  * **Details**
  *
  * Cookies are appended as `Set-Cookie` headers. Stream bodies are converted using
- * the supplied context.
+ * the supplied context, and are interrupted when `signal` aborts.
  *
  * Bodies are omitted for statuses 204, 205, and 304, or when `withoutBody` is true
  * (for example, for HEAD responses). Omitted raw `ReadableStream` bodies are
  * cancelled without awaiting completion, and cancellation errors are ignored.
  *
- * A raw `Response` body is returned as-is after the outer headers are merged
- * into it: outer headers replace native ones, and cookies are appended. When
- * its body is omitted, the bodyless `Response` keeps those merged headers and
- * uses the outer status for 204, 205 and 304, or the raw `Response` status
- * otherwise.
+ * A raw `Response` is returned as-is when there are no outer headers or cookies
+ * to merge. Otherwise, they are merged into a copy without modifying the raw
+ * response: outer headers replace native ones, and cookies are appended. When
+ * its body is omitted, the bodyless `Response` keeps those merged
+ * headers and uses the outer status for 204, 205 and 304, or the raw `Response`
+ * status otherwise.
  *
  * @stability unstable
  * @category converting
@@ -1373,6 +1385,7 @@ export const toWeb = (
   options?: {
     readonly withoutBody?: boolean | undefined
     readonly context?: Context.Context<never> | undefined
+    readonly signal?: AbortSignal | undefined
   }
 ): Response => {
   const headers = new globalThis.Headers(response.headers)
@@ -1387,15 +1400,13 @@ export const toWeb = (
   const withoutBody = outerOmitsBody || options?.withoutBody === true
   if (body._tag === "Raw" && body.body instanceof Response) {
     const raw = body.body
-    for (const [key, value] of headers as any) {
-      if (key === "set-cookie") {
-        raw.headers.append(key, value)
-      } else {
-        raw.headers.set(key, value)
-      }
-    }
     if (!withoutBody) {
-      return raw
+      if (headers.keys().next().done) {
+        return raw
+      }
+      const copy = new Response(raw.body, raw)
+      mergeHeaders(copy.headers, headers)
+      return copy
     }
     // A bodyless outer status is what the caller chose to send; otherwise the
     // body is only omitted for HEAD and the raw Response describes the resource.
@@ -1403,7 +1414,7 @@ export const toWeb = (
     return new Response(undefined, {
       status: source.status,
       statusText: source.statusText as string,
-      headers: raw.headers
+      headers: mergeHeaders(new globalThis.Headers(raw.headers), headers)
     })
   }
   if (withoutBody) {
@@ -1449,7 +1460,8 @@ export const toWeb = (
       return new Response(
         Stream.toReadableStreamWith(
           body.stream,
-          options?.context ?? Context.empty()
+          options?.context ?? Context.empty(),
+          { signal: options?.signal }
         ),
         {
           status: response.status,

package/src/http/Multipart.ts

@@ -689,6 +689,22 @@ const defaultWriteFile = (path: string, file: File) =>
     (fs) => Effect.mapError(Stream.run(file.content, fs.sink(path)), toMultipartError)
   )
 
+const maxPersistedFileNameBytes = 128
+const fileNameEncoder = new TextEncoder()
+
+// Keeps the trailing 128 UTF-8 bytes without splitting code points. Empty and dot names fall back to "file".
+const persistedFileName = (baseName: string): string => {
+  const codePoints = Array.from(baseName)
+  let fileName = ""
+  let bytes = 0
+  for (let i = codePoints.length - 1; i >= 0; i--) {
+    bytes += fileNameEncoder.encode(codePoints[i]).length
+    if (bytes > maxPersistedFileNameBytes) break
+    fileName = codePoints[i] + fileName
+  }
+  return fileName === "" || fileName === "." || fileName === ".." ? "file" : fileName
+}
+
 /**
  * Runs a channel of byte chunks and collects all output into a single
  * `Uint8Array`.
@@ -748,7 +764,7 @@ export const toPersisted = (
         return Effect.void
       }
       const file = part
-      const fileName = path_.basename(file.name).slice(-128)
+      const fileName = persistedFileName(path_.basename(file.name))
       let path = path_.join(dir, fileName)
       while (usedPaths.has(path)) {
         path = path_.join(dir, `${fileIndex++}-${fileName}`)

package/src/http-api/HttpApiScalar.ts

@@ -60,6 +60,11 @@ export type ScalarConfig = {
   layout?: "modern" | "classic"
   /** URL to a request proxy for the API client */
   proxyUrl?: string
+  /** Authentication preferences for the API client */
+  authentication?: {
+    /** OpenAPI security scheme names to select by default */
+    preferredSecurityScheme?: string | Array<string | Array<string>> | null
+  }
   /** Browser JavaScript function expression used by Scalar for documents and test requests */
   customFetch?: string
   /** Whether to show the sidebar */

package/src/internal/dateTime.ts

@@ -934,10 +934,6 @@ export const subtractDuration: {
     mapEpochMillis(self, (millis) => millis - Duration.toMillis(Duration.fromInputUnsafe(duration)))
 )
 
-const addMillis = (date: Date, amount: number): void => {
-  date.setTime(date.getTime() + amount)
-}
-
 /** @internal */
 export const add: {
   (
@@ -949,20 +945,26 @@ export const add: {
   ): A
 } = dual(
   2,
-  (self: DateTime.DateTime, parts: Partial<DateTime.DateTime.PartsForMath>): DateTime.DateTime =>
-    mutate(self, (date) => {
+  (self: DateTime.DateTime, parts: Partial<DateTime.DateTime.PartsForMath>): DateTime.DateTime => {
+    // time units move the instant, calendar units move the wall clock
+    const shifted = mutateUtc(self, (date) => {
       if (parts.milliseconds) {
-        addMillis(date, parts.milliseconds)
+        date.setTime(date.getTime() + parts.milliseconds)
       }
       if (parts.seconds) {
-        addMillis(date, parts.seconds * 1000)
+        date.setTime(date.getTime() + parts.seconds * 1000)
       }
       if (parts.minutes) {
-        addMillis(date, parts.minutes * 60 * 1000)
+        date.setTime(date.getTime() + parts.minutes * 60 * 1000)
       }
       if (parts.hours) {
-        addMillis(date, parts.hours * 60 * 60 * 1000)
+        date.setTime(date.getTime() + parts.hours * 60 * 60 * 1000)
       }
+    })
+    if (!parts.days && !parts.weeks && !parts.months && !parts.years) {
+      return shifted
+    }
+    return mutate(shifted, (date) => {
       if (parts.days) {
         date.setUTCDate(date.getUTCDate() + parts.days)
       }
@@ -989,6 +991,7 @@ export const add: {
         }
       }
     })
+  }
 )
 
 /** @internal */

package/src/internal/effect.ts

@@ -1507,14 +1507,19 @@ const succeedPayload = function(this: { readonly payload: any }, _value: unknown
 // V8 includes the property name of a stored continuation in its stack trace.
 // Other engines need an explicit frame for the stack cleaner to cut at.
 const continuationMarksStack = (() => {
-  if (getStackTraceLimit() === 0) return false
+  const limit = getStackTraceLimit()
+  if (limit === 0) return false
   const marker = "~effect/Effect/stackProbe"
   const probe = {
     [marker]: function stackProbe() {
-      return new Error().stack
+      return new Error()
     }
   }
-  return probe[marker]()?.includes("[as " + marker + "]") === true
+  // Only the probe frame is needed to detect the continuation property name.
+  setStackTraceLimit(1)
+  const error = probe[marker]()
+  setStackTraceLimit(limit)
+  return error.stack?.includes("[as " + marker + "]") === true
 })()
 const mapCont = function(this: { readonly payload: any }, value: any, fiber: FiberImpl) {
   const f = this.payload