@effect/platform 0.51.0 → 0.52.0

package/src/Http/App.ts

@@ -152,9 +152,7 @@ export const toWebHandlerRuntime = <R>(runtime: Runtime.Runtime<R>) => {
         const req = ServerRequest.fromWeb(request)
         ;(req as any)[resolveSymbol] = resolve
         ;(req as any)[rejectSymbol] = reject
-        const fiber = run(
-          Effect.provideService(handled, ServerRequest.ServerRequest, req)
-        )
+        const fiber = run(Effect.provideService(handled, ServerRequest.ServerRequest, req))
         request.signal.addEventListener("abort", () => {
           fiber.unsafeInterruptAsFork(ServerError.clientAbortFiberId)
         })

package/src/Http/Client.ts

@@ -459,6 +459,21 @@ export const withTracerDisabledWhen: {
   ): Effect.Effect<A, E, R>
 } = internal.withTracerDisabledWhen
 
+/**
+ * @since 1.0.0
+ * @category fiber refs
+ */
+export const currentTracerPropagation: FiberRef.FiberRef<boolean> = internal.currentTracerPropagation
+
+/**
+ * @since 1.0.0
+ * @category fiber refs
+ */
+export const withTracerPropagation: {
+  (enabled: boolean): <R, E, A>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  <R, E, A>(effect: Effect.Effect<A, E, R>, enabled: boolean): Effect.Effect<A, E, R>
+} = internal.withTracerPropagation
+
 /**
  * @since 1.0.0
  * @category fiber refs

package/src/Http/Middleware.ts

@@ -103,3 +103,14 @@ export const withTracerDisabledForUrls: {
  * @category constructors
  */
 export const xForwardedHeaders: <R, E>(httpApp: App.Default<E, R>) => App.Default<E, R> = internal.xForwardedHeaders
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const searchParamsParser: <E, R>(
+  httpApp: App.Default<E, R>
+) => App.Default<
+  E,
+  Exclude<R, ServerRequest.ParsedSearchParams>
+> = internal.searchParamsParser

package/src/Http/Router.ts

@@ -55,7 +55,10 @@ export declare namespace Router {
   /**
    * @since 1.0.0
    */
-  export type ExcludeProvided<A> = Exclude<A, RouteContext | ServerRequest.ServerRequest | Scope.Scope>
+  export type ExcludeProvided<A> = Exclude<
+    A,
+    RouteContext | ServerRequest.ServerRequest | ServerRequest.ParsedSearchParams | Scope.Scope
+  >
 }
 
 /**
@@ -99,7 +102,7 @@ export declare namespace Route {
   export type Handler<E, R> = Effect.Effect<
     ServerResponse.ServerResponse,
     E,
-    R | RouteContext | ServerRequest.ServerRequest
+    R | RouteContext | ServerRequest.ServerRequest | ServerRequest.ParsedSearchParams
   >
 }
 
@@ -123,7 +126,6 @@ export interface RouteContext {
   readonly [RouteContextTypeId]: RouteContextTypeId
   readonly params: Readonly<Record<string, string | undefined>>
   readonly route: Route<unknown, unknown>
-  readonly searchParams: Readonly<Record<string, string>>
 }
 
 /**
@@ -142,86 +144,75 @@ export const params: Effect.Effect<
   RouteContext
 > = internal.params
 
-/**
- * @since 1.0.0
- * @category route context
- */
-export const searchParams: Effect.Effect<
-  Readonly<Record<string, string>>,
-  never,
-  RouteContext
-> = internal.searchParams
-
 /**
  * @since 1.0.0
  * @category route context
  */
 export const schemaJson: <
-  R,
-  I extends Partial<
-    {
-      readonly method: Method.Method
-      readonly url: string
-      readonly cookies: Readonly<Record<string, string>>
-      readonly headers: Readonly<Record<string, string>>
-      readonly pathParams: Readonly<Record<string, string>>
-      readonly searchParams: Readonly<Record<string, string>>
-      readonly body: any
-    }
-  >,
-  A
->(
-  schema: Schema.Schema<A, I, R>,
-  options?: ParseOptions | undefined
-) => Effect.Effect<A, Error.RequestError | ParseResult.ParseError, RouteContext | R | ServerRequest.ServerRequest> =
-  internal.schemaJson
-
-/**
- * @since 1.0.0
- * @category route context
- */
-export const schemaNoBody: <
   R,
   I extends Partial<{
     readonly method: Method.Method
     readonly url: string
-    readonly cookies: Readonly<Record<string, string>>
-    readonly headers: Readonly<Record<string, string>>
-    readonly pathParams: Readonly<Record<string, string>>
-    readonly searchParams: Readonly<Record<string, string>>
+    readonly cookies: Readonly<Record<string, string | undefined>>
+    readonly headers: Readonly<Record<string, string | undefined>>
+    readonly pathParams: Readonly<Record<string, string | undefined>>
+    readonly searchParams: Readonly<Record<string, string | Array<string> | undefined>>
+    readonly body: any
   }>,
   A
 >(
   schema: Schema.Schema<A, I, R>,
   options?: ParseOptions | undefined
-) => Effect.Effect<A, ParseResult.ParseError, R | RouteContext | ServerRequest.ServerRequest> = internal.schemaNoBody
+) => Effect.Effect<
+  A,
+  Error.RequestError | ParseResult.ParseError,
+  RouteContext | R | ServerRequest.ServerRequest | ServerRequest.ParsedSearchParams
+> = internal.schemaJson
 
 /**
  * @since 1.0.0
  * @category route context
  */
-export const schemaParams: <R, I extends Readonly<Record<string, string>>, A>(
+export const schemaNoBody: <
+  R,
+  I extends Partial<
+    {
+      readonly method: Method.Method
+      readonly url: string
+      readonly cookies: Readonly<Record<string, string | undefined>>
+      readonly headers: Readonly<Record<string, string | undefined>>
+      readonly pathParams: Readonly<Record<string, string | undefined>>
+      readonly searchParams: Readonly<Record<string, string | Array<string> | undefined>>
+    }
+  >,
+  A
+>(
   schema: Schema.Schema<A, I, R>,
   options?: ParseOptions | undefined
-) => Effect.Effect<A, ParseResult.ParseError, RouteContext | R> = internal.schemaParams
+) => Effect.Effect<
+  A,
+  ParseResult.ParseError,
+  R | RouteContext | ServerRequest.ServerRequest | ServerRequest.ParsedSearchParams
+> = internal.schemaNoBody
 
 /**
  * @since 1.0.0
  * @category route context
  */
-export const schemaPathParams: <R, I extends Readonly<Record<string, string>>, A>(
+export const schemaParams: <R, I extends Readonly<Record<string, string | Array<string> | undefined>>, A>(
   schema: Schema.Schema<A, I, R>,
   options?: ParseOptions | undefined
-) => Effect.Effect<A, ParseResult.ParseError, RouteContext | R> = internal.schemaPathParams
+) => Effect.Effect<A, ParseResult.ParseError, R | RouteContext | ServerRequest.ParsedSearchParams> =
+  internal.schemaParams
 
 /**
  * @since 1.0.0
  * @category route context
  */
-export const schemaSearchParams: <R, I extends Readonly<Record<string, string>>, A>(
+export const schemaPathParams: <R, I extends Readonly<Record<string, string | undefined>>, A>(
   schema: Schema.Schema<A, I, R>,
   options?: ParseOptions | undefined
-) => Effect.Effect<A, ParseResult.ParseError, RouteContext | R> = internal.schemaSearchParams
+) => Effect.Effect<A, ParseResult.ParseError, R | RouteContext> = internal.schemaPathParams
 
 /**
  * @since 1.0.0
@@ -248,7 +239,7 @@ export const makeRoute: <E, R>(
   handler: Route.Handler<E, R>,
   prefix?: Option.Option<string>,
   uninterruptible?: boolean
-) => Route<E, Exclude<R, RouteContext | ServerRequest.ServerRequest | Scope.Scope>> = internal.makeRoute
+) => Route<E, Router.ExcludeProvided<R>> = internal.makeRoute
 
 /**
  * @since 1.0.0
@@ -295,8 +286,8 @@ export const mountApp: {
     self: Router<E, R>
   ) => Router<
     E1 | E,
-    | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>
-    | Exclude<R, RouteContext | ServerRequest.ServerRequest | Scope.Scope>
+    | Router.ExcludeProvided<R1>
+    | Router.ExcludeProvided<R>
   >
   <R, E, R1, E1>(
     self: Router<E, R>,
@@ -305,8 +296,8 @@ export const mountApp: {
     options?: { readonly includePrefix?: boolean | undefined } | undefined
   ): Router<
     E | E1,
-    | Exclude<R, RouteContext | ServerRequest.ServerRequest | Scope.Scope>
-    | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>
+    | Router.ExcludeProvided<R>
+    | Router.ExcludeProvided<R1>
   >
 } = internal.mountApp
 
@@ -343,13 +334,19 @@ export const all: {
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
   ): <R, E>(
     self: Router<E, R>
-  ) => Router<E1 | E, R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
+  ) => Router<
+    E1 | E,
+    R | Router.ExcludeProvided<R1>
+  >
   <R, E, R1, E1>(
     self: Router<E, R>,
     path: PathInput,
     handler: Route.Handler<E1, R1>,
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
-  ): Router<E | E1, R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
+  ): Router<
+    E | E1,
+    R | Router.ExcludeProvided<R1>
+  >
 } = internal.all
 
 /**
@@ -363,13 +360,13 @@ export const get: {
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
   ): <R, E>(
     self: Router<E, R>
-  ) => Router<E1 | E, R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
+  ) => Router<E1 | E, R | Router.ExcludeProvided<R1>>
   <R, E, R1, E1>(
     self: Router<E, R>,
     path: PathInput,
     handler: Route.Handler<E1, R1>,
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
-  ): Router<E | E1, R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
+  ): Router<E | E1, R | Router.ExcludeProvided<R1>>
 } = internal.get
 
 /**
@@ -383,13 +380,13 @@ export const post: {
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
   ): <R, E>(
     self: Router<E, R>
-  ) => Router<E1 | E, R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
+  ) => Router<E1 | E, R | Router.ExcludeProvided<R1>>
   <R, E, R1, E1>(
     self: Router<E, R>,
     path: PathInput,
     handler: Route.Handler<E1, R1>,
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
-  ): Router<E | E1, R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
+  ): Router<E | E1, R | Router.ExcludeProvided<R1>>
 } = internal.post
 
 /**
@@ -403,13 +400,13 @@ export const patch: {
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
   ): <R, E>(
     self: Router<E, R>
-  ) => Router<E1 | E, R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
+  ) => Router<E1 | E, R | Router.ExcludeProvided<R1>>
   <R, E, R1, E1>(
     self: Router<E, R>,
     path: PathInput,
     handler: Route.Handler<E1, R1>,
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
-  ): Router<E | E1, R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
+  ): Router<E | E1, R | Router.ExcludeProvided<R1>>
 } = internal.patch
 
 /**
@@ -423,13 +420,13 @@ export const put: {
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
   ): <R, E>(
     self: Router<E, R>
-  ) => Router<E1 | E, R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
+  ) => Router<E1 | E, R | Router.ExcludeProvided<R1>>
   <R, E, R1, E1>(
     self: Router<E, R>,
     path: PathInput,
     handler: Route.Handler<E1, R1>,
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
-  ): Router<E | E1, R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
+  ): Router<E | E1, R | Router.ExcludeProvided<R1>>
 } = internal.put
 
 /**
@@ -443,13 +440,13 @@ export const del: {
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
   ): <R, E>(
     self: Router<E, R>
-  ) => Router<E1 | E, R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
+  ) => Router<E1 | E, R | Router.ExcludeProvided<R1>>
   <R, E, R1, E1>(
     self: Router<E, R>,
     path: PathInput,
     handler: Route.Handler<E1, R1>,
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
-  ): Router<E | E1, R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
+  ): Router<E | E1, R | Router.ExcludeProvided<R1>>
 } = internal.del
 
 /**
@@ -463,13 +460,13 @@ export const head: {
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
   ): <R, E>(
     self: Router<E, R>
-  ) => Router<E1 | E, R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
+  ) => Router<E1 | E, R | Router.ExcludeProvided<R1>>
   <R, E, R1, E1>(
     self: Router<E, R>,
     path: PathInput,
     handler: Route.Handler<E1, R1>,
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
-  ): Router<E | E1, R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
+  ): Router<E | E1, R | Router.ExcludeProvided<R1>>
 } = internal.head
 
 /**
@@ -483,13 +480,13 @@ export const options: {
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
   ): <R, E>(
     self: Router<E, R>
-  ) => Router<E1 | E, R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
+  ) => Router<E1 | E, R | Router.ExcludeProvided<R1>>
   <R, E, R1, E1>(
     self: Router<E, R>,
     path: PathInput,
     handler: Route.Handler<E1, R1>,
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
-  ): Router<E | E1, R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
+  ): Router<E | E1, R | Router.ExcludeProvided<R1>>
 } = internal.options
 
 /**
@@ -499,11 +496,11 @@ export const options: {
 export const use: {
   <E, R, R1, E1>(
     f: (self: Route.Handler<E, R>) => App.Default<E1, R1>
-  ): (self: Router<E, R>) => Router<E1, Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
+  ): (self: Router<E, R>) => Router<E1, Router.ExcludeProvided<R1>>
   <E, R, R1, E1>(
     self: Router<E, R>,
     f: (self: Route.Handler<E, R>) => App.Default<E1, R1>
-  ): Router<E1, Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
+  ): Router<E1, Router.ExcludeProvided<R1>>
 } = internal.use
 
 /**
@@ -513,11 +510,11 @@ export const use: {
 export const catchAll: {
   <E, E2, R2>(
     f: (e: E) => Route.Handler<E2, R2>
-  ): <R>(self: Router<E, R>) => Router<E2, R | Exclude<R2, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
+  ): <R>(self: Router<E, R>) => Router<E2, R | Router.ExcludeProvided<R2>>
   <R, E, E2, R2>(
     self: Router<E, R>,
     f: (e: E) => Route.Handler<E2, R2>
-  ): Router<E2, R | Exclude<R2, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
+  ): Router<E2, R | Router.ExcludeProvided<R2>>
 } = internal.catchAll
 
 /**
@@ -527,11 +524,11 @@ export const catchAll: {
 export const catchAllCause: {
   <E, E2, R2>(
     f: (e: Cause.Cause<E>) => Route.Handler<E2, R2>
-  ): <R>(self: Router<E, R>) => Router<E2, R | Exclude<R2, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
+  ): <R>(self: Router<E, R>) => Router<E2, R | Router.ExcludeProvided<R2>>
   <R, E, E2, R2>(
     self: Router<E, R>,
     f: (e: Cause.Cause<E>) => Route.Handler<E2, R2>
-  ): Router<E2, R | Exclude<R2, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
+  ): Router<E2, R | Router.ExcludeProvided<R2>>
 } = internal.catchAllCause
 
 /**
@@ -544,12 +541,12 @@ export const catchTag: {
     f: (e: Extract<E, { _tag: K }>) => Route.Handler<E1, R1>
   ): <R>(
     self: Router<E, R>
-  ) => Router<E1 | Exclude<E, { _tag: K }>, R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
+  ) => Router<E1 | Exclude<E, { _tag: K }>, R | Router.ExcludeProvided<R1>>
   <R, E, K extends E extends { _tag: string } ? E["_tag"] : never, E1, R1>(
     self: Router<E, R>,
     k: K,
     f: (e: Extract<E, { _tag: K }>) => Route.Handler<E1, R1>
-  ): Router<E1 | Exclude<E, { _tag: K }>, R | Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>>
+  ): Router<E1 | Exclude<E, { _tag: K }>, R | Router.ExcludeProvided<R1>>
 } = internal.catchTag
 
 /**
@@ -572,11 +569,10 @@ export const catchTags: {
       [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect.Effect<any, infer E, any> ? E : never
     }[keyof Cases],
     | R
-    | Exclude<
+    | Router.ExcludeProvided<
       {
         [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect.Effect<any, any, infer R> ? R : never
-      }[keyof Cases],
-      RouteContext | ServerRequest.ServerRequest | Scope.Scope
+      }[keyof Cases]
     >
   >
   <
@@ -594,11 +590,10 @@ export const catchTags: {
       [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect.Effect<any, infer E, any> ? E : never
     }[keyof Cases],
     | R
-    | Exclude<
+    | Router.ExcludeProvided<
       {
         [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect.Effect<any, any, infer R> ? R : never
-      }[keyof Cases],
-      RouteContext | ServerRequest.ServerRequest | Scope.Scope
+      }[keyof Cases]
     >
   >
 } = internal.catchTags
@@ -632,7 +627,7 @@ export const provideServiceEffect: {
   ) => Router<
     E1 | E,
     | Exclude<R, Context.Tag.Identifier<T>>
-    | Exclude<Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>, Context.Tag.Identifier<T>>
+    | Exclude<Router.ExcludeProvided<R1>, Context.Tag.Identifier<T>>
   >
   <R, E, T extends Context.Tag<any, any>, R1, E1>(
     self: Router<E, R>,
@@ -641,6 +636,6 @@ export const provideServiceEffect: {
   ): Router<
     E | E1,
     | Exclude<R, Context.Tag.Identifier<T>>
-    | Exclude<Exclude<R1, RouteContext | ServerRequest.ServerRequest | Scope.Scope>, Context.Tag.Identifier<T>>
+    | Exclude<Router.ExcludeProvided<R1>, Context.Tag.Identifier<T>>
   >
 } = internal.provideServiceEffect

package/src/Http/ServerRequest.ts

@@ -77,6 +77,28 @@ export interface ServerRequest extends IncomingMessage.IncomingMessage<Error.Req
  */
 export const ServerRequest: Context.Tag<ServerRequest, ServerRequest> = internal.serverRequestTag
 
+/**
+ * @since 1.0.0
+ * @category search params
+ */
+export interface ParsedSearchParams {
+  readonly _: unique symbol
+}
+
+/**
+ * @since 1.0.0
+ * @category search params
+ */
+export const ParsedSearchParams: Context.Tag<ParsedSearchParams, ReadonlyRecord<string, string | Array<string>>> =
+  internal.parsedSearchParamsTag
+
+/**
+ * @since 1.0.0
+ * @category search params
+ */
+export const searchParamsFromURL: (url: URL) => ReadonlyRecord<string, string | Array<string>> =
+  internal.searchParamsFromURL
+
 /**
  * @since 1.0.0
  * @category accessors
@@ -125,6 +147,15 @@ export const schemaHeaders: <R, I extends Readonly<Record<string, string>>, A>(
   options?: ParseOptions | undefined
 ) => Effect.Effect<A, ParseResult.ParseError, ServerRequest | R> = internal.schemaHeaders
 
+/**
+ * @since 1.0.0
+ * @category schema
+ */
+export const schemaSearchParams: <R, I extends Readonly<Record<string, string | Array<string> | undefined>>, A>(
+  schema: Schema.Schema<A, I, R>,
+  options?: ParseOptions | undefined
+) => Effect.Effect<A, ParseResult.ParseError, ParsedSearchParams | R> = internal.schemaSearchParams
+
 /**
  * @since 1.0.0
  * @category schema

package/src/Http/UrlParams.ts

@@ -20,7 +20,10 @@ export interface UrlParams extends ReadonlyArray<readonly [string, string]> {}
  * @since 1.0.0
  * @category models
  */
-export type Input = Readonly<Record<string, string>> | Iterable<readonly [string, string]> | URLSearchParams
+export type Input =
+  | Readonly<Record<string, string | ReadonlyArray<string>>>
+  | Iterable<readonly [string, string]>
+  | URLSearchParams
 
 /**
  * @since 1.0.0
@@ -30,7 +33,17 @@ export const fromInput = (input: Input): UrlParams => {
   if (Symbol.iterator in input) {
     return Arr.fromIterable(input)
   }
-  return Arr.fromIterable(Object.entries(input))
+  const out: Array<readonly [string, string]> = []
+  for (const [key, value] of Object.entries(input)) {
+    if (Array.isArray(value)) {
+      for (let i = 0; i < value.length; i++) {
+        out.push([key, value[i]])
+      }
+    } else {
+      out.push([key, value as string])
+    }
+  }
+  return out
 }
 
 /**

package/src/internal/http/client.ts

@@ -53,6 +53,23 @@ export const withTracerDisabledWhen = dual<
   ) => Effect.Effect<A, E, R>
 >(2, (self, pred) => Effect.locally(self, currentTracerDisabledWhen, pred))
 
+/** @internal */
+export const currentTracerPropagation = globalValue(
+  Symbol.for("@effect/platform/Http/Client/currentTracerPropagation"),
+  () => FiberRef.unsafeMake(true)
+)
+
+/** @internal */
+export const withTracerPropagation = dual<
+  (
+    enabled: boolean
+  ) => <R, E, A>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <R, E, A>(
+    effect: Effect.Effect<A, E, R>,
+    enabled: boolean
+  ) => Effect.Effect<A, E, R>
+>(2, (self, enabled) => Effect.locally(self, currentTracerPropagation, enabled))
+
 /** @internal */
 export const currentFetchOptions = globalValue(
   Symbol.for("@effect/platform/Http/Client/currentFetchOptions"),
@@ -115,7 +132,8 @@ export const makeDefault = (
           return Effect.fail(new Error.RequestError({ request, reason: "InvalidUrl", error: urlResult.left }))
         }
         const url = urlResult.right
-        const tracerDisabled = fiber.getFiberRef(currentTracerDisabledWhen)(request)
+        const tracerDisabled = !fiber.getFiberRef(FiberRef.currentTracerEnabled) ||
+          fiber.getFiberRef(currentTracerDisabledWhen)(request)
         if (tracerDisabled) {
           return Effect.zipRight(
             addAbort,
@@ -145,10 +163,13 @@ export const makeDefault = (
               for (const name in redactedHeaders) {
                 span.attribute(`http.request.header.${name}`, String(redactedHeaders[name]))
               }
+              request = fiber.getFiberRef(currentTracerPropagation)
+                ? internalRequest.setHeaders(request, TraceContext.toHeaders(span))
+                : request
               return Effect.tap(
                 Effect.withParentSpan(
                   f(
-                    internalRequest.setHeaders(request, TraceContext.toHeaders(span)),
+                    request,
                     url,
                     controller.signal,
                     fiber

package/src/internal/http/middleware.ts

@@ -6,10 +6,12 @@ import { globalValue } from "effect/GlobalValue"
 import * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
 import type * as Predicate from "effect/Predicate"
+import type * as App from "../../Http/App.js"
 import * as Headers from "../../Http/Headers.js"
 import type * as Middleware from "../../Http/Middleware.js"
 import * as ServerError from "../../Http/ServerError.js"
 import * as ServerRequest from "../../Http/ServerRequest.js"
+import type { ServerResponse } from "../../Http/ServerResponse.js"
 import * as TraceContext from "../../Http/TraceContext.js"
 
 /** @internal */
@@ -179,3 +181,20 @@ export const xForwardedHeaders = make((httpApp) =>
       })
       : request)
 )
+
+/** @internal */
+export const searchParamsParser = <E, R>(httpApp: App.Default<E, R>) =>
+  Effect.withFiberRuntime<
+    ServerResponse,
+    E,
+    ServerRequest.ServerRequest | Exclude<R, ServerRequest.ParsedSearchParams>
+  >((fiber) => {
+    const context = fiber.getFiberRef(FiberRef.currentContext)
+    const request = Context.unsafeGet(context, ServerRequest.ServerRequest)
+    const params = ServerRequest.searchParamsFromURL(new URL(request.url))
+    return Effect.locally(
+      httpApp,
+      FiberRef.currentContext,
+      Context.add(context, ServerRequest.ParsedSearchParams, params)
+    ) as any
+  })