effect 4.0.0-beta.4 → 4.0.0-beta.41

package/src/unstable/devtools/DevToolsClient.ts

@@ -4,6 +4,7 @@
 import * as Cause from "../../Cause.ts"
 import * as Deferred from "../../Deferred.ts"
 import * as Effect from "../../Effect.ts"
+import * as Fiber from "../../Fiber.ts"
 import * as Layer from "../../Layer.ts"
 import * as Metric from "../../Metric.ts"
 import * as Queue from "../../Queue.ts"
@@ -23,9 +24,14 @@ const ResponseSchema = Schema.toCodecJson(DevToolsSchema.Response)
  * @since 4.0.0
  * @category tags
  */
-export class DevToolsClient extends ServiceMap.Service<DevToolsClient, {
-  readonly sendUnsafe: (_: DevToolsSchema.Span | DevToolsSchema.SpanEvent) => void
-}>()("effect/devtools/DevToolsClient") {}
+export class DevToolsClient extends ServiceMap.Service<
+  DevToolsClient,
+  {
+    readonly sendUnsafe: (
+      _: DevToolsSchema.Span | DevToolsSchema.SpanEvent
+    ) => void
+  }
+>()("effect/devtools/DevToolsClient") {}
 
 const makeEffect = Effect.gen(function*() {
   const socket = yield* Socket.Socket
@@ -37,7 +43,9 @@ const makeEffect = Effect.gen(function*() {
     Queue.offerUnsafe(requests, toMetricsSnapshot(services))
   })
 
-  const handleResponse = (response: DevToolsSchema.Response): Effect.Effect<void> => {
+  const handleResponse = (
+    response: DevToolsSchema.Response
+  ): Effect.Effect<void> => {
     switch (response._tag) {
       case "MetricsRequest": {
         return offerMetricsSnapshot
@@ -48,7 +56,7 @@ const makeEffect = Effect.gen(function*() {
     }
   }
 
-  yield* Stream.fromQueue(requests).pipe(
+  const fiber = yield* Stream.fromQueue(requests).pipe(
     Stream.pipeThroughChannel(
       Ndjson.duplexSchemaString(Socket.toChannelString(socket), {
         inputSchema: RequestSchema,
@@ -57,12 +65,15 @@ const makeEffect = Effect.gen(function*() {
     ),
     Stream.onFirst(() => Deferred.completeWith(connected, Effect.void)),
     Stream.runForEach(handleResponse),
-    Effect.forkScoped
+    Effect.forkDetach
   )
 
   yield* Effect.addFinalizer(() =>
     offerMetricsSnapshot.pipe(
-      Effect.andThen(Effect.flatMap(Effect.fiberId, (id) => Queue.failCause(requests, Cause.interrupt(id))))
+      Effect.andThen(
+        Effect.flatMap(Effect.fiberId, (id) => Queue.failCause(requests, Cause.interrupt(id)))
+      ),
+      Effect.andThen(Fiber.await(fiber))
     )
   )
 
@@ -84,7 +95,9 @@ const makeEffect = Effect.gen(function*() {
   })
 })
 
-const toMetricsSnapshot = (services: ServiceMap.ServiceMap<never>): DevToolsSchema.MetricsSnapshot => ({
+const toMetricsSnapshot = (
+  services: ServiceMap.ServiceMap<never>
+): DevToolsSchema.MetricsSnapshot => ({
   _tag: "MetricsSnapshot",
   metrics: Metric.snapshotUnsafe(services)
 })
@@ -108,11 +121,7 @@ export const make: Effect.Effect<
  * @since 4.0.0
  * @category layers
  */
-export const layer: Layer.Layer<
-  DevToolsClient,
-  never,
-  Socket.Socket
-> = Layer.effect(DevToolsClient, make)
+export const layer: Layer.Layer<DevToolsClient, never, Socket.Socket> = Layer.effect(DevToolsClient, make)
 
 const makeTracerEffect = Effect.gen(function*() {
   const client = yield* DevToolsClient
@@ -162,10 +171,6 @@ export const makeTracer: Effect.Effect<Tracer.Tracer, never, DevToolsClient> = m
  * @since 4.0.0
  * @category layers
  */
-export const layerTracer: Layer.Layer<
-  never,
-  never,
-  Socket.Socket
-> = Layer.effect(Tracer.Tracer, makeTracer).pipe(
+export const layerTracer: Layer.Layer<never, never, Socket.Socket> = Layer.effect(Tracer.Tracer, makeTracer).pipe(
   Layer.provide(layer)
 )

package/src/unstable/devtools/DevToolsSchema.ts

@@ -1,7 +1,11 @@
 /**
  * @since 4.0.0
  */
+import * as Exit from "../../Exit.ts"
+import { identity } from "../../Function.ts"
+import type * as Option from "../../Option.ts"
 import * as Schema from "../../Schema.ts"
+import * as SchemaTransformation from "../../SchemaTransformation.ts"
 
 /**
  * @since 4.0.0
@@ -25,7 +29,16 @@ export type SpanStatusStarted = Schema.Schema.Type<typeof SpanStatusStarted>
 export const SpanStatusEnded = Schema.Struct({
   _tag: Schema.tag("Ended"),
   startTime: Schema.BigInt,
-  endTime: Schema.BigInt
+  endTime: Schema.BigInt,
+  exit: Schema.Exit(Schema.Void, Schema.DefectWithStack, Schema.DefectWithStack).pipe(
+    Schema.decodeTo(
+      Schema.Exit(Schema.Unknown, Schema.Unknown, Schema.Unknown),
+      SchemaTransformation.transform({
+        decode: identity,
+        encode: Exit.asVoid
+      })
+    )
+  )
 })
 
 /**
@@ -80,7 +93,7 @@ export interface Span {
   readonly sampled: boolean
   readonly attributes: ReadonlyMap<string, unknown>
   readonly status: SpanStatus
-  readonly parent: ParentSpan | undefined
+  readonly parent: Option.Option<ParentSpan>
 }
 
 /**
@@ -95,7 +108,7 @@ export const Span: Schema.Codec<Span> = Schema.Struct({
   sampled: Schema.Boolean,
   attributes: Schema.ReadonlyMap(Schema.String, Schema.Any),
   status: SpanStatus,
-  parent: Schema.UndefinedOr(Schema.suspend(() => ParentSpan))
+  parent: Schema.Option(Schema.suspend(() => ParentSpan))
 })
 
 /**

package/src/unstable/encoding/Ndjson.ts

@@ -61,13 +61,13 @@ export const encodeString = <IE = never, Done = unknown>(): Channel.Channel<
  * @category constructors
  */
 export const encode = <IE = never, Done = unknown>(): Channel.Channel<
-  Arr.NonEmptyReadonlyArray<Uint8Array<ArrayBuffer>>,
+  Arr.NonEmptyReadonlyArray<Uint8Array>,
   IE | NdjsonError,
   Done,
   Arr.NonEmptyReadonlyArray<unknown>,
   IE,
   Done
-> => Channel.map(encodeString(), Arr.map((_) => encoder.encode(_) as Uint8Array<ArrayBuffer>))
+> => Channel.map(encodeString(), Arr.map((_) => encoder.encode(_)))
 
 /**
  * @since 4.0.0
@@ -77,7 +77,7 @@ export const encodeSchema = <S extends Schema.Top>(
   schema: S
 ) =>
 <IE = never, Done = unknown>(): Channel.Channel<
-  Arr.NonEmptyReadonlyArray<Uint8Array<ArrayBuffer>>,
+  Arr.NonEmptyReadonlyArray<Uint8Array>,
   NdjsonError | Schema.SchemaError | IE,
   Done,
   Arr.NonEmptyReadonlyArray<S["Type"]>,
@@ -141,7 +141,7 @@ export const decode = <IE = never, Done = unknown>(options?: {
   Arr.NonEmptyReadonlyArray<unknown>,
   IE | NdjsonError,
   Done,
-  Arr.NonEmptyReadonlyArray<Uint8Array<ArrayBuffer>>,
+  Arr.NonEmptyReadonlyArray<Uint8Array>,
   IE,
   Done
 > => {
@@ -161,7 +161,7 @@ export const decodeSchema = <S extends Schema.Top>(
   Arr.NonEmptyReadonlyArray<S["Type"]>,
   Schema.SchemaError | NdjsonError | IE,
   Done,
-  Arr.NonEmptyReadonlyArray<Uint8Array<ArrayBuffer>>,
+  Arr.NonEmptyReadonlyArray<Uint8Array>,
   IE,
   Done,
   S["DecodingServices"]
@@ -201,10 +201,10 @@ export const duplex: {
     }
   ): <R, IE, OE, OutDone, InDone>(
     self: Channel.Channel<
-      Arr.NonEmptyReadonlyArray<Uint8Array<ArrayBuffer>>,
+      Arr.NonEmptyReadonlyArray<Uint8Array>,
       OE,
       OutDone,
-      Arr.NonEmptyReadonlyArray<Uint8Array<ArrayBuffer>>,
+      Arr.NonEmptyReadonlyArray<Uint8Array>,
       IE | NdjsonError,
       InDone,
       R
@@ -224,10 +224,10 @@ export const duplex: {
    */
   <R, IE, OE, OutDone, InDone>(
     self: Channel.Channel<
-      Arr.NonEmptyReadonlyArray<Uint8Array<ArrayBuffer>>,
+      Arr.NonEmptyReadonlyArray<Uint8Array>,
       OE,
       OutDone,
-      Arr.NonEmptyReadonlyArray<Uint8Array<ArrayBuffer>>,
+      Arr.NonEmptyReadonlyArray<Uint8Array>,
       IE | NdjsonError,
       InDone,
       R
@@ -246,10 +246,10 @@ export const duplex: {
   >
 } = dual((args) => Channel.isChannel(args[0]), <R, IE, OE, OutDone, InDone>(
   self: Channel.Channel<
-    Arr.NonEmptyReadonlyArray<Uint8Array<ArrayBuffer>>,
+    Arr.NonEmptyReadonlyArray<Uint8Array>,
     OE,
     OutDone,
-    Arr.NonEmptyReadonlyArray<Uint8Array<ArrayBuffer>>,
+    Arr.NonEmptyReadonlyArray<Uint8Array>,
     IE | NdjsonError,
     InDone,
     R
@@ -373,10 +373,10 @@ export const duplexSchema: {
     }
   ): <OutErr, OutDone, InErr, InDone, R>(
     self: Channel.Channel<
-      Arr.NonEmptyReadonlyArray<Uint8Array<ArrayBuffer>>,
+      Arr.NonEmptyReadonlyArray<Uint8Array>,
       OutErr,
       OutDone,
-      Arr.NonEmptyReadonlyArray<Uint8Array<ArrayBuffer>>,
+      Arr.NonEmptyReadonlyArray<Uint8Array>,
       NdjsonError | Schema.SchemaError | InErr,
       InDone,
       R
@@ -396,10 +396,10 @@ export const duplexSchema: {
    */
   <Out extends Schema.Top, In extends Schema.Top, OutErr, OutDone, InErr, InDone, R>(
     self: Channel.Channel<
-      Arr.NonEmptyReadonlyArray<Uint8Array<ArrayBuffer>>,
+      Arr.NonEmptyReadonlyArray<Uint8Array>,
       OutErr,
       OutDone,
-      Arr.NonEmptyReadonlyArray<Uint8Array<ArrayBuffer>>,
+      Arr.NonEmptyReadonlyArray<Uint8Array>,
       NdjsonError | Schema.SchemaError | InErr,
       InDone,
       R
@@ -420,10 +420,10 @@ export const duplexSchema: {
   >
 } = dual(2, <Out extends Schema.Top, In extends Schema.Top, OutErr, OutDone, InErr, InDone, R>(
   self: Channel.Channel<
-    Arr.NonEmptyReadonlyArray<Uint8Array<ArrayBuffer>>,
+    Arr.NonEmptyReadonlyArray<Uint8Array>,
     OutErr,
     OutDone,
-    Arr.NonEmptyReadonlyArray<Uint8Array<ArrayBuffer>>,
+    Arr.NonEmptyReadonlyArray<Uint8Array>,
     NdjsonError | Schema.SchemaError | InErr,
     InDone,
     R

package/src/unstable/encoding/Sse.ts

@@ -311,7 +311,7 @@ export const encode = <IE, Done>(): Channel.Channel<
       let done = false
       const pull = upstream.pipe(
         Effect.map(Arr.map(encoder.write)),
-        Effect.catchIf(Retry.filter as any, (retry: any) => {
+        Effect.catchFilter(Retry.filter as any, (retry: any) => {
           done = true
           return Effect.succeed(Arr.of(encoder.write(retry)))
         }),
@@ -326,11 +326,9 @@ export const encode = <IE, Done>(): Channel.Channel<
  * @category Encoding
  */
 export const encodeSchema = <
-  S extends Schema.Codec<
-    any,
+  S extends Schema.Encoder<
     { readonly id?: string | undefined; readonly event: string; readonly data: string },
-    any,
-    any
+    unknown
   >,
   IE,
   Done

package/src/unstable/eventlog/EventJournal.ts

@@ -252,7 +252,7 @@ export const makeMemory: Effect.Effect<EventJournal["Service"]> = Effect.gen(fun
             event,
             primaryKey,
             payload
-          }, { disableValidation: true })
+          }, { disableChecks: true })
         ),
         effect,
         (entry, exit) =>
@@ -399,7 +399,7 @@ export const makeIndexedDb = (options?: {
             event,
             primaryKey,
             payload
-          }, { disableValidation: true })
+          }, { disableChecks: true })
           return restore(effect(entry)).pipe(
             Effect.tap(
               idbReq("write", () =>

package/src/unstable/eventlog/EventLog.ts

@@ -14,6 +14,7 @@ import type * as Record from "../../Record.ts"
 import * as Redacted from "../../Redacted.ts"
 import * as Schema from "../../Schema.ts"
 import type * as Scope from "../../Scope.ts"
+import * as Semaphore from "../../Semaphore.ts"
 import * as ServiceMap from "../../ServiceMap.ts"
 import type { Covariant } from "../../Types.ts"
 import { Reactivity } from "../reactivity/Reactivity.ts"
@@ -366,7 +367,7 @@ export const groupCompaction = <Events extends Event.Any, R>(
                 Effect.orDie
               ) as any,
               primaryKey: event.primaryKey(payload)
-            }, { disableValidation: true })
+            }, { disableChecks: true })
             yield* write(entry)
           })
 
@@ -481,7 +482,7 @@ const make = Effect.gen(function*() {
       readonly write: (entry: Entry) => Effect.Effect<void>
     }) => Effect.Effect<void>
   }>()
-  const journalSemaphore = yield* Effect.makeSemaphore(1)
+  const journalSemaphore = yield* Semaphore.make(1)
 
   const reactivity = yield* Reactivity
   const reactivityKeys: Record<string, ReadonlyArray<string>> = {}

package/src/unstable/eventlog/SqlEventLogJournal.ts

@@ -199,7 +199,7 @@ export const make = (options?: {
             event,
             primaryKey,
             payload
-          }, { disableValidation: true })
+          }, { disableChecks: true })
           yield* insertEntry(toEntryRow(entry))
           const value = yield* effect(entry)
           yield* PubSub.publish(pubsub, entry)
@@ -280,7 +280,7 @@ const toEntry = (row: EntryRow): EventJournal.Entry =>
     event: row.event,
     primaryKey: row.primary_key,
     payload: row.payload
-  }, { disableValidation: true })
+  }, { disableChecks: true })
 
 const toEntryRow = (entry: EventJournal.Entry): EntryRow => ({
   id: entry.id,

package/src/unstable/http/Cookies.ts

@@ -5,6 +5,7 @@ import * as Data from "../../Data.ts"
 import * as Duration from "../../Duration.ts"
 import { dual } from "../../Function.ts"
 import * as Inspectable from "../../Inspectable.ts"
+import * as Option from "../../Option.ts"
 import { type Pipeable, pipeArguments } from "../../Pipeable.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as Record from "../../Record.ts"
@@ -86,7 +87,7 @@ export interface Cookie extends Inspectable.Inspectable {
   readonly options?: {
     readonly domain?: string | undefined
     readonly expires?: Date | undefined
-    readonly maxAge?: Duration.DurationInput | undefined
+    readonly maxAge?: Duration.Input | undefined
     readonly path?: string | undefined
     readonly priority?: "low" | "medium" | "high" | undefined
     readonly httpOnly?: boolean | undefined
@@ -418,7 +419,7 @@ export function makeCookie(
       return Result.fail(CookiesError.fromReason("InvalidCookiePath"))
     }
 
-    if (options.maxAge !== undefined && !Duration.isFinite(Duration.fromDurationInputUnsafe(options.maxAge))) {
+    if (options.maxAge !== undefined && !Duration.isFinite(Duration.fromInputUnsafe(options.maxAge))) {
       return Result.fail(CookiesError.fromReason("CookieInfinityMaxAge"))
     }
   }
@@ -566,17 +567,17 @@ export const get: {
    * @since 4.0.0
    * @category combinators
    */
-  (name: string): (self: Cookies) => Cookie | undefined
+  (name: string): (self: Cookies) => Option.Option<Cookie>
   /**
    * Get a cookie from a Cookies object
    *
    * @since 4.0.0
    * @category combinators
    */
-  (self: Cookies, name: string): Cookie | undefined
+  (self: Cookies, name: string): Option.Option<Cookie>
 } = dual(
   (args) => isCookies(args[0]),
-  (self: Cookies, name: string): Cookie | undefined => self.cookies[name]
+  (self: Cookies, name: string): Option.Option<Cookie> => Option.fromUndefinedOr(self.cookies[name])
 )
 
 /**
@@ -592,19 +593,17 @@ export const getValue: {
    * @since 4.0.0
    * @category combinators
    */
-  (name: string): (self: Cookies) => string | undefined
+  (name: string): (self: Cookies) => Option.Option<string>
   /**
    * Get a cookie from a Cookies object
    *
    * @since 4.0.0
    * @category combinators
    */
-  (self: Cookies, name: string): string | undefined
+  (self: Cookies, name: string): Option.Option<string>
 } = dual(
   (args) => isCookies(args[0]),
-  (self: Cookies, name: string): string | undefined => {
-    return self.cookies[name]?.value
-  }
+  (self: Cookies, name: string): Option.Option<string> => Option.map(get(self, name), (cookie) => cookie.value)
 )
 
 /**
@@ -668,6 +667,90 @@ export const setUnsafe: {
     ))
 )
 
+/**
+ * Add an expired cookie to a Cookies object
+ *
+ * @since 4.0.0
+ * @category combinators
+ */
+export const expireCookie: {
+  /**
+   * Add an expired cookie to a Cookies object
+   *
+   * @since 4.0.0
+   * @category combinators
+   */
+  (
+    name: string,
+    options?: Omit<NonNullable<Cookie["options"]>, "expires" | "maxAge">
+  ): (self: Cookies) => Result.Result<Cookies, CookiesError>
+  /**
+   * Add an expired cookie to a Cookies object
+   *
+   * @since 4.0.0
+   * @category combinators
+   */
+  (
+    self: Cookies,
+    name: string,
+    options?: Omit<NonNullable<Cookie["options"]>, "expires" | "maxAge">
+  ): Result.Result<Cookies, CookiesError>
+} = dual(
+  (args) => isCookies(args[0]),
+  (
+    self: Cookies,
+    name: string,
+    options?: Omit<NonNullable<Cookie["options"]>, "expires" | "maxAge">
+  ) =>
+    set(self, name, "", {
+      ...options,
+      maxAge: 0,
+      expires: new Date(0)
+    })
+)
+
+/**
+ * Add an expired cookie to a Cookies object, throwing an error if invalid
+ *
+ * @since 4.0.0
+ * @category combinators
+ */
+export const expireCookieUnsafe: {
+  /**
+   * Add an expired cookie to a Cookies object, throwing an error if invalid
+   *
+   * @since 4.0.0
+   * @category combinators
+   */
+  (
+    name: string,
+    options?: Omit<NonNullable<Cookie["options"]>, "expires" | "maxAge">
+  ): (self: Cookies) => Cookies
+  /**
+   * Add an expired cookie to a Cookies object, throwing an error if invalid
+   *
+   * @since 4.0.0
+   * @category combinators
+   */
+  (
+    self: Cookies,
+    name: string,
+    options?: Omit<NonNullable<Cookie["options"]>, "expires" | "maxAge">
+  ): Cookies
+} = dual(
+  (args) => isCookies(args[0]),
+  (
+    self: Cookies,
+    name: string,
+    options?: Omit<NonNullable<Cookie["options"]>, "expires" | "maxAge">
+  ): Cookies =>
+    setUnsafe(self, name, "", {
+      ...options,
+      maxAge: 0,
+      expires: new Date(0)
+    })
+)
+
 /**
  * Add multiple cookies to a Cookies object
  *
@@ -763,7 +846,7 @@ export function serializeCookie(self: Cookie): string {
   const options = self.options
 
   if (options.maxAge !== undefined) {
-    const maxAge = Duration.toSeconds(Duration.fromDurationInputUnsafe(options.maxAge))
+    const maxAge = Duration.toSeconds(Duration.fromInputUnsafe(options.maxAge))
     str += "; Max-Age=" + Math.trunc(maxAge)
   }
 

package/src/unstable/http/Etag.ts

@@ -4,6 +4,7 @@
 import * as Effect from "../../Effect.ts"
 import type * as FileSystem from "../../FileSystem.ts"
 import * as Layer from "../../Layer.ts"
+import * as Option from "../../Option.ts"
 import * as ServiceMap from "../../ServiceMap.ts"
 import type * as Body from "./HttpBody.ts"
 
@@ -54,9 +55,10 @@ export class Generator extends ServiceMap.Service<Generator, {
 }>()("effect/http/Etag/Generator") {}
 
 const fromFileInfo = (info: FileSystem.File.Info) => {
-  const mtime = info.mtime
-    ? info.mtime.getTime().toString(16)
-    : "0"
+  const mtime = Option.match(info.mtime, {
+    onNone: () => "0",
+    onSome: (mtime) => mtime.getTime().toString(16)
+  })
   return `${info.size.toString(16)}-${mtime}`
 }
 

package/src/unstable/http/Headers.ts

@@ -6,6 +6,7 @@ import * as Equ from "../../Equivalence.ts"
 import { dual } from "../../Function.ts"
 import * as Hash from "../../Hash.ts"
 import * as Inspectable from "../../Inspectable.ts"
+import * as Option from "../../Option.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as Record from "../../Record.ts"
 import * as Redactable from "../../Redactable.ts"
@@ -44,22 +45,37 @@ export interface Headers extends Redactable.Redactable {
   readonly [key: string]: string
 }
 
-const Proto = Object.assign(Object.create(null), Inspectable.BaseProto, {
-  [TypeId]: TypeId,
-  [Redactable.symbolRedactable](
-    this: Headers,
-    context: ServiceMap.ServiceMap<never>
-  ): Record<string, string | Redacted.Redacted<string>> {
-    return redact(this, ServiceMap.get(context, CurrentRedactedNames))
+const Proto = Object.create(null)
+
+Object.defineProperties(Proto, {
+  [TypeId]: {
+    value: TypeId
   },
-  toJSON() {
-    return Redactable.redact(this)
+  [Redactable.symbolRedactable]: {
+    value(this: Headers, context: ServiceMap.ServiceMap<never>): Record<string, string | Redacted.Redacted<string>> {
+      return redact(this, ServiceMap.get(context, CurrentRedactedNames))
+    }
   },
-  [Equal.symbol](this: Headers, that: Headers): boolean {
-    return Equivalence(this, that)
+  toJSON: {
+    value(this: Headers) {
+      return Redactable.redact(this)
+    }
+  },
+  [Equal.symbol]: {
+    value(this: Headers, that: Headers): boolean {
+      return Equivalence(this, that)
+    }
   },
-  [Hash.symbol](this: Headers): number {
-    return Hash.structure(this)
+  [Hash.symbol]: {
+    value(this: Headers): number {
+      return Hash.structure(this)
+    }
+  },
+  toString: {
+    value: Inspectable.BaseProto.toString
+  },
+  [Inspectable.NodeInspectSymbol]: {
+    value: Inspectable.BaseProto[Inspectable.NodeInspectSymbol]
   }
 })
 
@@ -190,24 +206,24 @@ export const get: {
    * @since 4.0.0
    * @category combinators
    */
-  (key: string): (self: Headers) => string | undefined
+  (key: string): (self: Headers) => Option.Option<string>
   /**
    * @since 4.0.0
    * @category combinators
    */
-  (self: Headers, key: string): string | undefined
+  (self: Headers, key: string): Option.Option<string>
 } = dual<
   /**
    * @since 4.0.0
    * @category combinators
    */
-  (key: string) => (self: Headers) => string | undefined,
+  (key: string) => (self: Headers) => Option.Option<string>,
   /**
    * @since 4.0.0
    * @category combinators
    */
-  (self: Headers, key: string) => string | undefined
->(2, (self, key) => self[key.toLowerCase()])
+  (self: Headers, key: string) => Option.Option<string>
+>(2, (self, key) => Option.fromUndefinedOr(self[key.toLowerCase()]))
 
 /**
  * @since 4.0.0
@@ -337,6 +353,40 @@ export const remove: {
   return out
 })
 
+/**
+ * @since 4.0.0
+ * @category combinators
+ */
+export const removeMany: {
+  /**
+   * @since 4.0.0
+   * @category combinators
+   */
+  (keys: Iterable<string>): (self: Headers) => Headers
+  /**
+   * @since 4.0.0
+   * @category combinators
+   */
+  (self: Headers, keys: Iterable<string>): Headers
+} = dual<
+  /**
+   * @since 4.0.0
+   * @category combinators
+   */
+  (keys: Iterable<string>) => (self: Headers) => Headers,
+  /**
+   * @since 4.0.0
+   * @category combinators
+   */
+  (self: Headers, keys: Iterable<string>) => Headers
+>(2, (self, keys) => {
+  const out = make(self)
+  for (const key of keys) {
+    delete out[key.toLowerCase()]
+  }
+  return out
+})
+
 /**
  * @since 4.0.0
  * @category combinators