effect 4.0.0-rc.111 → 4.0.0-rc.113

package/src/Layer.ts

@@ -1543,6 +1543,8 @@ export const effectDiscard = <X, E, R>(effect: Effect<X, E, R>): Layer<never, E,
 export const suspend = <A, E, R>(evaluate: LazyArg<Layer<A, E, R>>): Layer<A, E, R> =>
   fromBuildMemo((memoMap, scope) => internalEffect.suspend(() => evaluate().build(memoMap, scope)))
 
+const unwrapKey = Context.Service<Layer<any, any, any>>("effect/Layer/unwrap")
+
 /**
  * Unwraps a `Layer` from an `Effect`, flattening the nested structure.
  *
@@ -1579,10 +1581,7 @@ export const suspend = <A, E, R>(evaluate: LazyArg<Layer<A, E, R>>): Layer<A, E,
  */
 export const unwrap = <A, E1, R1, E, R>(
   self: Effect<Layer<A, E1, R1>, E, R>
-): Layer<A, E | E1, R1 | Exclude<R, Scope.Scope>> => {
-  const service = Context.Service<Layer<A, E1, R1>>("effect/Layer/unwrap")
-  return flatMap(effect(service)(self), Context.get(service))
-}
+): Layer<A, E | E1, R1 | Exclude<R, Scope.Scope>> => flatMap(effect(unwrapKey)(self), Context.get(unwrapKey))
 
 const mergeAllEffect = <Layers extends [Layer<never, any, any>, ...Array<Layer<never, any, any>>]>(
   layers: Layers,
@@ -3164,7 +3163,28 @@ export const tapError: {
    * @category sequencing
    * @since 2.0.0
    */
-  <E, XE extends E, RIn2, E2, X>(f: (e: XE) => Effect<X, E2, RIn2>): <RIn, ROut>(self: Layer<ROut, E, RIn>) => Layer<ROut, E | E2, RIn | Exclude<RIn2, Scope.Scope>>
+  <E, _XE extends E, RIn2, E2, X>(f: (e: Types.NoInfer<E>) => Effect<X, E2, RIn2>): <RIn, ROut>(self: Layer<ROut, E, RIn>) => Layer<ROut, E | E2, RIn | Exclude<RIn2, Scope.Scope>>
+  /**
+   * Performs the specified effect if this layer fails.
+   *
+   * **When to use**
+   *
+   * Use to run logging, metrics, or other effects when layer construction fails
+   * while preserving the original typed error.
+   *
+   * **Details**
+   *
+   * The callback receives the typed error. If the callback succeeds, the layer
+   * still fails with the original error; if the callback fails, that failure is
+   * added to the layer's error type.
+   *
+   * @see {@link tap} for running an effect when layer construction succeeds
+   * @see {@link tapCause} for inspecting the full failure cause, including defects and interruption
+   *
+   * @category sequencing
+   * @since 2.0.0
+   */
+  <E, RIn2, E2, X>(f: (e: E) => Effect<X, E2, RIn2>): <RIn, ROut, E1 extends E = E>(self: Layer<ROut, E1, RIn>) => Layer<ROut, E1 | E2, RIn | Exclude<RIn2, Scope.Scope>>
   /**
    * Performs the specified effect if this layer fails.
    *
@@ -3185,15 +3205,15 @@ export const tapError: {
    * @category sequencing
    * @since 2.0.0
    */
-  <RIn, E, XE extends E, ROut, RIn2, E2, X>(self: Layer<ROut, E, RIn>, f: (e: XE) => Effect<X, E2, RIn2>): Layer<ROut, E | E2, RIn | Exclude<RIn2, Scope.Scope>>
-} = dual(2, <RIn, E, XE extends E, ROut, RIn2, E2, X>(
+  <RIn, E, _XE extends E, ROut, RIn2, E2, X>(self: Layer<ROut, E, RIn>, f: (e: Types.NoInfer<E>) => Effect<X, E2, RIn2>): Layer<ROut, E | E2, RIn | Exclude<RIn2, Scope.Scope>>
+} = dual(2, <RIn, E, ROut, RIn2, E2, X>(
   self: Layer<ROut, E, RIn>,
-  f: (e: XE) => Effect<X, E2, RIn2>
+  f: (e: E) => Effect<X, E2, RIn2>
 ): Layer<ROut, E | E2, RIn | Exclude<RIn2, Scope.Scope>> =>
   fromBuild((memoMap, scope) =>
     internalEffect.catch_(
       self.build(memoMap, scope),
-      (error) => Scope.provide(internalEffect.andThen(f(error as XE), internalEffect.fail(error)), scope)
+      (error) => Scope.provide(internalEffect.andThen(f(error), internalEffect.fail(error)), scope)
     )
   ))
 
@@ -3240,7 +3260,29 @@ export const tapCause: {
    * @category sequencing
    * @since 4.0.0
    */
-  <E, XE extends E, RIn2, E2, X>(f: (cause: Cause.Cause<XE>) => Effect<X, E2, RIn2>): <RIn, ROut>(self: Layer<ROut, E, RIn>) => Layer<ROut, E | E2, RIn | Exclude<RIn2, Scope.Scope>>
+  <E, _XE extends E, RIn2, E2, X>(f: (cause: Cause.Cause<Types.NoInfer<E>>) => Effect<X, E2, RIn2>): <RIn, ROut>(self: Layer<ROut, E, RIn>) => Layer<ROut, E | E2, RIn | Exclude<RIn2, Scope.Scope>>
+  /**
+   * Performs the specified effect when this layer fails with any cause.
+   *
+   * **When to use**
+   *
+   * Use to run diagnostics or reporting when layer construction fails and the
+   * full `Cause` is needed.
+   *
+   * **Details**
+   *
+   * The callback receives the layer's `Cause`, so it can inspect typed errors,
+   * defects, and interruption information. If the callback succeeds, the layer
+   * fails again with the original cause; if the callback fails, that failure is
+   * added to the layer's error type.
+   *
+   * @see {@link tapError} for observing only typed layer construction errors
+   * @see {@link catchCause} for recovering from a layer construction failure by switching to another layer
+   *
+   * @category sequencing
+   * @since 4.0.0
+   */
+  <E, RIn2, E2, X>(f: (cause: Cause.Cause<E>) => Effect<X, E2, RIn2>): <RIn, ROut, E1 extends E = E>(self: Layer<ROut, E1, RIn>) => Layer<ROut, E1 | E2, RIn | Exclude<RIn2, Scope.Scope>>
   /**
    * Performs the specified effect when this layer fails with any cause.
    *
@@ -3262,19 +3304,18 @@ export const tapCause: {
    * @category sequencing
    * @since 4.0.0
    */
-  <RIn, E, XE extends E, ROut, RIn2, E2, X>(
+  <RIn, E, _XE extends E, ROut, RIn2, E2, X>(
     self: Layer<ROut, E, RIn>,
-    f: (cause: Cause.Cause<XE>) => Effect<X, E2, RIn2>
+    f: (cause: Cause.Cause<Types.NoInfer<E>>) => Effect<X, E2, RIn2>
   ): Layer<ROut, E | E2, RIn | Exclude<RIn2, Scope.Scope>>
-} = dual(2, <RIn, E, XE extends E, ROut, RIn2, E2, X>(
+} = dual(2, <RIn, E, ROut, RIn2, E2, X>(
   self: Layer<ROut, E, RIn>,
-  f: (cause: Cause.Cause<XE>) => Effect<X, E2, RIn2>
+  f: (cause: Cause.Cause<E>) => Effect<X, E2, RIn2>
 ): Layer<ROut, E | E2, RIn | Exclude<RIn2, Scope.Scope>> =>
   fromBuild((memoMap, scope) =>
     internalEffect.catchCause(
       self.build(memoMap, scope),
-      (cause) =>
-        Scope.provide(internalEffect.andThen(f(cause as Cause.Cause<XE>), internalEffect.failCause(cause)), scope)
+      (cause) => Scope.provide(internalEffect.andThen(f(cause), internalEffect.failCause(cause)), scope)
     )
   ))
 
@@ -4596,7 +4637,7 @@ export const withSpan: {
             (span) => internalEffect.addFinalizer((exit) => options.onEnd!(span, exit))
           )
           : internalEffect.makeSpanScoped(name, options),
-        (span) => withParentSpan(self, span)
+        (span) => withParentSpan(self, span, options)
       )
     )
   }
@@ -4609,7 +4650,7 @@ export const withSpan: {
             (span) => internalEffect.addFinalizer((exit) => options.onEnd!(span, exit))
           )
           : internalEffect.makeSpanScoped(name, options),
-        (span) => withParentSpan(self, span)
+        (span) => withParentSpan(self, span, options)
       )
     )
 } as any

package/src/LayerMap.ts

@@ -15,6 +15,7 @@ import * as Effect from "./Effect.ts"
 import { identity } from "./Function.ts"
 import { getStackTraceLimit, setStackTraceLimit } from "./internal/stackTraceLimit.ts"
 import * as Layer from "./Layer.ts"
+import type * as Option from "./Option.ts"
 import * as RcMap from "./RcMap.ts"
 import * as Scope from "./Scope.ts"
 import type { Mutable, NoExcessProperties } from "./Types.ts"
@@ -92,6 +93,18 @@ export interface LayerMap<in out K, in out I, in out E = never> {
    */
   contextEffect(key: K): Effect.Effect<Context.Context<I>, E, Scope.Scope>
 
+  /**
+   * Retains and returns the context for a key only when it is currently cached.
+   *
+   * **Details**
+   *
+   * `Option.none` means no entry is currently cached or the `LayerMap` is closed;
+   * no layer is built for a missing key. An existing in-flight entry is awaited.
+   *
+   * @since 4.0.0
+   */
+  contextEffectOption(key: K): Effect.Effect<Option.Option<Context.Context<I>>, E, Scope.Scope>
+
   /**
    * Invalidates the resource associated with the key.
    */
@@ -183,6 +196,7 @@ export const make: <
     rcMap,
     get: (key) => Layer.effectContext(RcMap.get(rcMap, key)),
     contextEffect: (key) => RcMap.get(rcMap, key),
+    contextEffectOption: (key) => RcMap.getOption(rcMap, key),
     invalidate: (key) => RcMap.invalidate(rcMap, key)
   })
 })
@@ -316,6 +330,20 @@ export interface TagClass<
    */
   readonly contextEffect: (key: K) => Effect.Effect<Context.Context<I>, E, Scope.Scope | Self>
 
+  /**
+   * Retains and returns the context for a key only when it is currently cached.
+   *
+   * **Details**
+   *
+   * `Option.none` means no entry is currently cached or the `LayerMap` is closed;
+   * no layer is built for a missing key. An existing in-flight entry is awaited.
+   *
+   * @since 4.0.0
+   */
+  readonly contextEffectOption: (
+    key: K
+  ) => Effect.Effect<Option.Option<Context.Context<I>>, E, Scope.Scope | Self>
+
   /**
    * Invalidates the resource associated with the key.
    */
@@ -395,7 +423,7 @@ export const Service = <Self>() =>
     : Options extends { readonly layers: infer Layers } ? keyof Layers
     : never,
   Service.Success<Options>,
-  Options extends { readonly preload: true } ? never : Service.Error<Options>,
+  Service.Error<Options>,
   Service.Services<Options>,
   Options extends { readonly preload: true } ? Service.Error<Options>
     : Options extends { readonly preloadKeys: Iterable<any> } ? Service.Error<Options>
@@ -403,11 +431,13 @@ export const Service = <Self>() =>
   Options extends { readonly dependencies: ReadonlyArray<Layer.Layer<any, any, any>> } ? Options["dependencies"][number]
     : never
 > => {
-  const Err = globalThis.Error as any
   const limit = getStackTraceLimit()
-  setStackTraceLimit(2)
-  const creationError = new Err()
-  setStackTraceLimit(limit)
+  let creationError: Error | undefined
+  if (limit !== 0) {
+    setStackTraceLimit(2)
+    creationError = new globalThis.Error()
+    setStackTraceLimit(limit)
+  }
 
   function TagClass() {}
   const TagClass_ = TagClass as any as Mutable<TagClass<Self, Id, string, any, any, any, any, any>>
@@ -415,7 +445,7 @@ export const Service = <Self>() =>
   TagClass.key = id
   Object.defineProperty(TagClass, "stack", {
     get() {
-      return creationError.stack
+      return creationError?.stack
     }
   })
 
@@ -430,6 +460,8 @@ export const Service = <Self>() =>
 
   TagClass_.get = (key: string) => Layer.unwrap(Effect.map(TagClass_, (layerMap) => layerMap.get(key)))
   TagClass_.contextEffect = (key: string) => Effect.flatMap(TagClass_, (layerMap) => layerMap.contextEffect(key))
+  TagClass_.contextEffectOption = (key: string) =>
+    Effect.flatMap(TagClass_, (layerMap) => layerMap.contextEffectOption(key))
   TagClass_.invalidate = (key: string) => Effect.flatMap(TagClass_, (layerMap) => layerMap.invalidate(key))
 
   return TagClass as any

package/src/LayerRef.ts

@@ -349,11 +349,13 @@ export const Service = <Self>() =>
   [Preload] extends [true] ? E : never,
   Deps[number]
 > => {
-  const Err = globalThis.Error as any
   const limit = getStackTraceLimit()
-  setStackTraceLimit(2)
-  const creationError = new Err()
-  setStackTraceLimit(limit)
+  let creationError: Error | undefined
+  if (limit !== 0) {
+    setStackTraceLimit(2)
+    creationError = new globalThis.Error()
+    setStackTraceLimit(limit)
+  }
 
   function TagClass() {}
   const TagClass_ = TagClass as any as Mutable<TagClass<Self, Id, any, any, any, any, any>>
@@ -361,7 +363,7 @@ export const Service = <Self>() =>
   TagClass.key = id
   Object.defineProperty(TagClass, "stack", {
     get() {
-      return creationError.stack
+      return creationError?.stack
     }
   })
 

package/src/Logger.ts

@@ -887,7 +887,9 @@ export const batched = dual<
 
 /**
  * A `Logger` which outputs logs in a "pretty" format and writes them to the
- * console.
+ * console. Chooses between tty and browser implementation. If the runtime
+ * platform is known and fixed, prefer {@link consolePrettyBrowser} or
+ * {@link consolePrettyTty}.
  *
  * **Details**
  *
@@ -898,24 +900,135 @@ export const batched = dual<
  * **Example** (Logging with pretty console output)
  *
  * ```ts import.meta.vitest
- * import { Logger } from "effect"
+ * import { Effect, Logger } from "effect"
+ *
+ * const prettyLogger = Logger.layer([Logger.consolePretty()])
+ *
+ * Effect.log("hello").pipe(
+ *   Effect.withLogSpan('label'),
+ *   Effect.annotateLogs('key', 'value'),
+ *   Effect.provide(prettyLogger),
+ *   Effect.runSync
+ * )
+ * ```
+ *
+ * **Example** (Logging with console.error, when the environment has TTY)
+ *
+ * ```ts import.meta.vitest
+ * import { Effect, Layer, Logger } from "effect"
  *
- * const prettyLogger = Logger.consolePretty({ colors: false })
- * Logger.isLogger(prettyLogger) // => true
+ * const prettyLoggerLayer = Layer.merge(
+ *   Logger.layer([Logger.consolePretty()]),
+ *   Layer.succeed(Logger.LogToStderr, true)
+ * )
+ *
+ * Effect.log('hello').pipe(
+ *   Effect.provide(prettyLoggerLayer),
+ *   Effect.runSync
+ * )
  * ```
  *
+ * @see {@link consolePrettyBrowser} for browser-specific implementation
+ * @see {@link consolePrettyTty} for the TTY-mode implementation
  * @category constructors
  * @since 4.0.0
  */
 export const consolePretty: (
   options?: {
     readonly colors?: "auto" | boolean | undefined
-    readonly stderr?: boolean | undefined
     readonly formatDate?: ((date: Date) => string) | undefined
     readonly mode?: "browser" | "tty" | "auto" | undefined
   }
 ) => Logger<unknown, void> = effect.consolePretty
 
+/**
+ * A `Logger` which outputs logs in a "pretty" format and writes them to the
+ * console. Intended to be used on platforms with a browser console.
+ *
+ * **Details**
+ *
+ * For example, pretty output can render as
+ * `[09:37:17.579] INFO (#1) label=0ms: hello` followed by an annotation line
+ * such as `key: value`.
+ *
+ * **Example** (Logging with pretty console output)
+ *
+ * ```ts import.meta.vitest
+ * import { Effect, Logger } from "effect"
+ *
+ * const prettyLogger = Logger.layer([Logger.consolePrettyBrowser()])
+ *
+ * Effect.log("hello").pipe(
+ *   Effect.withLogSpan('label'),
+ *   Effect.annotateLogs('key', 'value'),
+ *   Effect.provide(prettyLogger),
+ *   Effect.runSync
+ * )
+ * ```
+ *
+ * @see {@link consolePretty} for the platform-independent implementation
+ * @category constructors
+ * @since 4.0.0
+ */
+export const consolePrettyBrowser: (
+  options?: {
+    readonly colors?: boolean | undefined
+    readonly formatDate?: ((date: Date) => string) | undefined
+  }
+) => Logger<unknown, void> = effect.prettyLoggerBrowser
+
+/**
+ * A `Logger` which outputs logs in a "pretty" format and writes them to the
+ * console. Intended to be used on platforms with tty console.
+ *
+ * **Details**
+ *
+ * For example, pretty output can render as
+ * `[09:37:17.579] INFO (#1) label=0ms: hello` followed by an annotation line
+ * such as `key: value`.
+ *
+ * **Example** (Logging with pretty console output)
+ *
+ * ```ts import.meta.vitest
+ * import { Effect, Logger } from "effect"
+ *
+ * const prettyLogger = Logger.layer([Logger.consolePrettyTty()])
+ *
+ * Effect.log("hello").pipe(
+ *   Effect.withLogSpan('label'),
+ *   Effect.annotateLogs('key', 'value'),
+ *   Effect.provide(prettyLogger),
+ *   Effect.runSync
+ * )
+ * ```
+ *
+ * **Example** (Logging with console.error)
+ *
+ * ```ts import.meta.vitest
+ * import { Effect, Layer, Logger } from "effect"
+ *
+ * const prettyLoggerLayer = Layer.merge(
+ *   Logger.layer([Logger.consolePrettyTty()]),
+ *   Layer.succeed(Logger.LogToStderr, true)
+ * )
+ *
+ * Effect.log('hello').pipe(
+ *   Effect.provide(prettyLoggerLayer),
+ *   Effect.runSync
+ * )
+ * ```
+ *
+ * @see {@link consolePretty} for the platform-independent implementation
+ * @category constructors
+ * @since 4.0.0
+ */
+export const consolePrettyTty: (
+  options?: {
+    readonly colors?: boolean | undefined
+    readonly formatDate?: ((date: Date) => string) | undefined
+  }
+) => Logger<unknown, void> = effect.prettyLoggerTty
+
 /**
  * A `Logger` which outputs logs using the [logfmt](https://brandur.org/logfmt)
  * style and writes them to the console.
@@ -1086,9 +1199,8 @@ export const layer = <
  *
  * const writes: Array<string> = []
  * const file = {
- *   write: (buffer: Uint8Array) => Effect.sync(() => {
+ *   writeAll: (buffer: Uint8Array) => Effect.sync(() => {
  *     writes.push(new TextDecoder().decode(buffer).trim())
- *     return FileSystem.Size(buffer.length)
  *   })
  * } as unknown as FileSystem.File
  * const fileSystem = FileSystem.makeNoop({ open: () => Effect.succeed(file) })
@@ -1112,9 +1224,8 @@ export const layer = <
  *
  * const writes: Array<string> = []
  * const file = {
- *   write: (buffer: Uint8Array) => Effect.sync(() => {
+ *   writeAll: (buffer: Uint8Array) => Effect.sync(() => {
  *     writes.push(new TextDecoder().decode(buffer).trim())
- *     return FileSystem.Size(buffer.length)
  *   })
  * } as unknown as FileSystem.File
  * const fileSystem = FileSystem.makeNoop({ open: () => Effect.succeed(file) })
@@ -1153,9 +1264,8 @@ export const toFile = dual<
    *
    * const writes: Array<string> = []
    * const file = {
-   *   write: (buffer: Uint8Array) => Effect.sync(() => {
+   *   writeAll: (buffer: Uint8Array) => Effect.sync(() => {
    *     writes.push(new TextDecoder().decode(buffer).trim())
-   *     return FileSystem.Size(buffer.length)
    *   })
    * } as unknown as FileSystem.File
    * const fileSystem = FileSystem.makeNoop({ open: () => Effect.succeed(file) })
@@ -1179,9 +1289,8 @@ export const toFile = dual<
    *
    * const writes: Array<string> = []
    * const file = {
-   *   write: (buffer: Uint8Array) => Effect.sync(() => {
+   *   writeAll: (buffer: Uint8Array) => Effect.sync(() => {
    *     writes.push(new TextDecoder().decode(buffer).trim())
-   *     return FileSystem.Size(buffer.length)
    *   })
    * } as unknown as FileSystem.File
    * const fileSystem = FileSystem.makeNoop({ open: () => Effect.succeed(file) })
@@ -1229,9 +1338,8 @@ export const toFile = dual<
    *
    * const writes: Array<string> = []
    * const file = {
-   *   write: (buffer: Uint8Array) => Effect.sync(() => {
+   *   writeAll: (buffer: Uint8Array) => Effect.sync(() => {
    *     writes.push(new TextDecoder().decode(buffer).trim())
-   *     return FileSystem.Size(buffer.length)
    *   })
    * } as unknown as FileSystem.File
    * const fileSystem = FileSystem.makeNoop({ open: () => Effect.succeed(file) })
@@ -1255,9 +1363,8 @@ export const toFile = dual<
    *
    * const writes: Array<string> = []
    * const file = {
-   *   write: (buffer: Uint8Array) => Effect.sync(() => {
+   *   writeAll: (buffer: Uint8Array) => Effect.sync(() => {
    *     writes.push(new TextDecoder().decode(buffer).trim())
-   *     return FileSystem.Size(buffer.length)
    *   })
    * } as unknown as FileSystem.File
    * const fileSystem = FileSystem.makeNoop({ open: () => Effect.succeed(file) })
@@ -1297,7 +1404,7 @@ export const toFile = dual<
       const encoder = new TextEncoder()
       return yield* batched(self, {
         window: options?.batchWindow ?? 1000,
-        flush: (output) => effect.ignore(logFile.write(encoder.encode(output.join("\n") + "\n")))
+        flush: (output) => effect.ignore(logFile.writeAll(encoder.encode(output.join("\n") + "\n")))
       })
     })
 )

package/src/ManagedRuntime.ts

@@ -317,7 +317,7 @@ export const make = <R, ER>(
               self.cachedContext = context
             })
         ),
-        { ...defaultRunOptions, scheduler: fiber.currentScheduler }
+        { ...defaultRunOptions, scheduler: fiber.cache.scheduler }
       )
     }
     return Effect.flatten(Fiber.await(buildFiber))

package/src/Match.ts

@@ -20,6 +20,22 @@ import type { Unify } from "./Unify.ts"
 
 const TypeId = internal.TypeId
 
+// The conditional must stay deferred until P is inferred. Replacing it with an
+// intersection loses contextual typing for nested generic calls (microsoft/TypeScript#52864).
+type Contextual<P, Fallback> = internal.Contextual<P, Fallback>
+
+type TagHandlers<D extends string, R, Ret> = {
+  readonly [Tag in Types.Tags<D, R> & string]: (_: Extract<R, Record<D, Tag>>) => Ret
+}
+
+type PartialTagHandlers<D extends string, R, Ret> = {
+  readonly [Tag in Types.Tags<D, R> & string]?: ((_: Extract<R, Record<D, Tag>>) => Ret) | undefined
+}
+
+type ValueTagHandlers<I> = {
+  readonly [Tag in Types.Tags<"_tag", I> & string]: (_: Extract<I, { readonly _tag: Tag }>) => any
+}
+
 /**
  * Marker used by `Matcher` to distinguish matchers created with `Match.value`.
  *
@@ -316,10 +332,13 @@ export const type: <I>() => Matcher<I, Types.Without<never>, I, never, never> =
 /**
  * Creates a reusable matcher from a function that selects the value to match.
  *
+ * **Details**
+ *
  * The compiled matcher keeps the selector's original argument list. Case
  * handlers receive the narrowed selected value followed by those arguments.
  *
- * @example
+ * **Example** (Creating a reusable matcher)
+ *
  * ```ts import.meta.vitest
  * import { Match } from "effect"
  *
@@ -448,9 +467,9 @@ export const valueTags: {
   <
     const I,
     P extends
-      & { readonly [Tag in Types.Tags<"_tag", I> & string]: (_: Extract<I, { readonly _tag: Tag }>) => any }
+      & ValueTagHandlers<I>
       & { readonly [Tag in Exclude<keyof P, Types.Tags<"_tag", I>>]: never }
-  >(fields: P): (input: I) => Unify<ReturnType<P[keyof P]>>
+  >(fields: Contextual<P, ValueTagHandlers<I>>): (input: I) => Unify<ReturnType<P[keyof P]>>
   /**
    * Creates a match function for a specific value with discriminated union handling.
    *
@@ -483,9 +502,9 @@ export const valueTags: {
   <
     const I,
     P extends
-      & { readonly [Tag in Types.Tags<"_tag", I> & string]: (_: Extract<I, { readonly _tag: Tag }>) => any }
+      & ValueTagHandlers<I>
       & { readonly [Tag in Exclude<keyof P, Types.Tags<"_tag", I>>]: never }
-  >(input: I, fields: P): Unify<ReturnType<P[keyof P]>>
+  >(input: I, fields: Contextual<P, ValueTagHandlers<I>>): Unify<ReturnType<P[keyof P]>>
 } = internal.valueTags
 
 /**
@@ -1024,10 +1043,10 @@ export const discriminators: <D extends string>(
   R,
   Ret,
   P extends
-    & { readonly [Tag in Types.Tags<D, R> & string]?: ((_: Extract<R, Record<D, Tag>>) => Ret) | undefined }
+    & PartialTagHandlers<D, R, Ret>
     & { readonly [Tag in Exclude<keyof P, Types.Tags<D, R>>]: never }
 >(
-  fields: P
+  fields: Contextual<P, PartialTagHandlers<D, R, Ret>>
 ) => <I, F, A, Pr>(
   self: Matcher<I, F, R, A, Pr, Ret>
 ) => Matcher<
@@ -1087,10 +1106,10 @@ export const discriminatorsExhaustive: <D extends string>(
   R,
   Ret,
   P extends
-    & { readonly [Tag in Types.Tags<D, R> & string]: (_: Extract<R, Record<D, Tag>>) => Ret }
+    & TagHandlers<D, R, Ret>
     & { readonly [Tag in Exclude<keyof P, Types.Tags<D, R>>]: never }
 >(
-  fields: P
+  fields: Contextual<P, TagHandlers<D, R, Ret>>
 ) => <I, F, A, Pr>(
   self: Matcher<I, F, R, A, Pr, Ret>
 ) => [Pr] extends [never] ? (u: I) => Unify<A | ReturnType<P[keyof P]>> : Unify<A | ReturnType<P[keyof P]>> =
@@ -1247,10 +1266,10 @@ export const tags: <
   R,
   Ret,
   P extends
-    & { readonly [Tag in Types.Tags<"_tag", R> & string]?: ((_: Extract<R, Record<"_tag", Tag>>) => Ret) | undefined }
+    & PartialTagHandlers<"_tag", R, Ret>
     & { readonly [Tag in Exclude<keyof P, Types.Tags<"_tag", R>>]: never }
 >(
-  fields: P
+  fields: Contextual<P, PartialTagHandlers<"_tag", R, Ret>>
 ) => <I, F, A, Pr>(
   self: Matcher<I, F, R, A, Pr, Ret>
 ) => Matcher<
@@ -1302,10 +1321,10 @@ export const tagsExhaustive: <
   R,
   Ret,
   P extends
-    & { readonly [Tag in Types.Tags<"_tag", R> & string]: (_: Extract<R, Record<"_tag", Tag>>) => Ret }
+    & TagHandlers<"_tag", R, Ret>
     & { readonly [Tag in Exclude<keyof P, Types.Tags<"_tag", R>>]: never }
 >(
-  fields: P
+  fields: Contextual<P, TagHandlers<"_tag", R, Ret>>
 ) => <I, F, A, Pr>(
   self: Matcher<I, F, R, A, Pr, Ret>
 ) => [Pr] extends [never] ? (u: I) => Unify<A | ReturnType<P[keyof P]>> : Unify<A | ReturnType<P[keyof P]>> =
@@ -2195,7 +2214,7 @@ export const exhaustive: <I, F, A, Pr, Ret, Args extends Array<any>>(
 ) => [Pr] extends [never] ? [Args] extends [[]] ? (u: I) => Unify<A> : (...args: Args) => Unify<A> : Unify<A> =
   internal.exhaustive
 
-const SafeRefinementId = "~effect/match/Match/SafeRefinement"
+const SafeRefinementId = "~effect/Match/SafeRefinement"
 
 /**
  * A safe refinement that narrows types without runtime errors.