effect 4.0.2 → 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/FindMyWay/internal/router.ts

@@ -338,13 +338,6 @@ class RouterImpl<A> implements Router.Router<A> {
         path = path.replace(FULL_PATH_REGEXP, "/")
       }
 
-      // This must be run before sanitizeUrl as the resulting function
-      // .sliceParameter must be constructed with same URL string used
-      // throughout the rest of this function.
-      if (this.options.ignoreDuplicateSlashes) {
-        path = removeDuplicateSlashes(path)
-      }
-
       let sanitizedUrl
       try {
         sanitizedUrl = safeDecodeURI(path)
@@ -355,6 +348,10 @@ class RouterImpl<A> implements Router.Router<A> {
         return undefined
       }
 
+      if (this.options.ignoreDuplicateSlashes) {
+        path = removeDuplicateSlashes(path)
+      }
+
       if (this.options.ignoreTrailingSlash) {
         path = trimLastSlash(path)
       }

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
         }),
@@ -1466,6 +1482,8 @@ export declare namespace WithRateLimiter {
  * 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**
  *
@@ -1486,6 +1504,8 @@ export const withRateLimiter: {
    * 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**
    *
@@ -1508,6 +1528,8 @@ export const withRateLimiter: {
    * 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**
    *
@@ -1551,14 +1573,36 @@ export const withRateLimiter: {
     return initialState
   }
 
+  const budgets = new Map<string, RateLimitBudget>()
+  const getBudget = (key: string): RateLimitBudget => {
+    let budget = budgets.get(key)
+    if (budget === undefined) {
+      budget = { sent: 0, observed: 0, remaining: 0, resetAt: 0 }
+      budgets.set(key, budget)
+    }
+    return budget
+  }
+
   const onResponse = options.disableResponseInspection
     ? undefined
-    : (clock: Clock, key: string, headers: Headers.Headers, tokens: number) => {
+    : (clock: Clock, key: string, headers: Headers.Headers, tokens: number, sent: number) => {
       const current = getState(key)
       const next = parseRateLimiterState(current, clock, headers, tokens, headerNames)
       if (next.limit !== current.limit || !Duration.equals(next.window, current.window)) {
         states.set(key, next)
       }
+      const remaining = parseRateLimitRemaining(headers, headerNames)
+      const budget = getBudget(key)
+      // responses to earlier requests carry stale counts
+      if (remaining === undefined || sent <= budget.observed) {
+        return
+      }
+      const resetAfter = parseRateLimitWindow(clock, headers, headerNames)
+      budget.observed = sent
+      budget.remaining = remaining
+      if (resetAfter !== undefined) {
+        budget.resetAt = clock.currentTimeMillisUnsafe() + Duration.toMillis(resetAfter)
+      }
     }
 
   return transform(self, function loop(effect, request, retries = 0): Effect.Effect<
@@ -1570,6 +1614,15 @@ export const withRateLimiter: {
     const clock = fiber.getRef(Clock)
     const key = resolveKey(request)
     const tokens = Math.max(resolveTokens(request), 1)
+    const budget = getBudget(key)
+    const now = clock.currentTimeMillisUnsafe()
+    // requests admitted after the observed one are not reflected in its count
+    if (budget.resetAt > now && budget.remaining - (budget.sent - budget.observed) < tokens) {
+      return Effect.flatMap(Effect.sleep(budget.resetAt - now), () => loop(effect, request, retries))
+    }
+    // counted at admission, so requests already admitted are sent even if a
+    // later response exhausts the budget
+    const sent = budget.sent += tokens
     const current = getState(key)
     const canRetry = options.times === undefined || retries < options.times
     function retry(retryAfter: Duration.Duration | undefined) {
@@ -1581,7 +1634,7 @@ export const withRateLimiter: {
       response: HttpClientResponse.HttpClientResponse,
       adaptive: RateLimiter.AdaptiveConsumeResult | undefined
     ) => {
-      onResponse?.(clock, key, response.headers, tokens)
+      onResponse?.(clock, key, response.headers, tokens, sent)
       if (options.disableResponseInspection || response.status !== 429) {
         return Effect.succeed</**
          * Applies request rate limiting using the `RateLimiter` service.
@@ -1591,6 +1644,8 @@ export const withRateLimiter: {
          * 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**
          *
@@ -1604,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.
@@ -1614,6 +1672,8 @@ export const withRateLimiter: {
          * 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**
          *
@@ -1637,6 +1697,8 @@ export const withRateLimiter: {
          * 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**
          *
@@ -1756,6 +1818,17 @@ interface RateLimiterState {
   readonly initial: boolean
 }
 
+interface RateLimitBudget {
+  /** Total tokens admitted for the key. */
+  sent: number
+  /** The `sent` total of the request whose remaining count was last applied. */
+  observed: number
+  /** The remaining count reported in response to the `observed` request. */
+  remaining: number
+  /** When the server budget resets, in epoch milliseconds. */
+  resetAt: number
+}
+
 const parseRateLimiterState = (
   state: RateLimiterState,
   clock: Clock,
@@ -1811,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)
   }
@@ -2363,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/HttpTraceContext.ts

@@ -93,7 +93,7 @@ export const b3: FromHeaders = (headers) => {
     return Option.none()
   }
   const parts = headers["b3"].split("-")
-  if (parts.length < 2) {
+  if (parts.length < 2 || isB3Ids(parts[0], parts[1]) === false) {
     return Option.none()
   }
   return Option.some(Tracer.externalSpan({
@@ -116,7 +116,10 @@ export const b3: FromHeaders = (headers) => {
  * @since 4.0.0
  */
 export const xb3: FromHeaders = (headers) => {
-  if (!(headers["x-b3-traceid"]) || !(headers["x-b3-spanid"])) {
+  if (
+    !(headers["x-b3-traceid"]) || !(headers["x-b3-spanid"]) ||
+    isB3Ids(headers["x-b3-traceid"], headers["x-b3-spanid"]) === false
+  ) {
     return Option.none()
   }
   return Option.some(Tracer.externalSpan({
@@ -130,6 +133,9 @@ export const xb3: FromHeaders = (headers) => {
 const w3cTraceId = /^[0-9a-f]{32}$/i
 const w3cSpanId = /^[0-9a-f]{16}$/i
 
+const b3TraceId = /^(?:[0-9a-f]{16}|[0-9a-f]{32})$/i
+const isB3Ids = (traceId: string, spanId: string): boolean => b3TraceId.test(traceId) && w3cSpanId.test(spanId)
+
 /**
  * Decodes an external span safely from the W3C `traceparent` header.
  *

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 */