effect 4.0.0-rc.112 → 4.0.0-rc.113

package/src/JsonPatch.ts

@@ -307,8 +307,8 @@ function tokenize(pointer: string): Array<string> {
   return pointer.split("/").slice(1).map(unescapeToken)
 }
 
-/** Convert a reference token to a non-negative array index (rejects `-` and negatives). */
-function toIndex(token: string): number {
+/** Converts a JSON Pointer reference token to a non-negative array index. */
+function toJsonPointerArrayIndex(token: string): number {
   if (!/^(0|[1-9]\d*)$/.test(token)) {
     throw new Error(`Invalid array index: "${token}"`)
   }
@@ -332,7 +332,7 @@ function applyOperation(doc: Schema.Json, op: JsonPatchOperation): Schema.Json {
     if (lastToken === "-" && op.op !== "add") {
       throw new Error(`"-" is not valid for ${op.op} at "${op.path}".`)
     }
-    const index = lastToken === "-" ? parent.length : toIndex(lastToken)
+    const index = lastToken === "-" ? parent.length : toJsonPointerArrayIndex(lastToken)
     const maxIndex = op.op === "add" ? parent.length : parent.length - 1
     if (index > maxIndex) throw new Error(`Array index out of bounds at "${op.path}".`)
     const updated = parent.slice()
@@ -374,7 +374,7 @@ function resolveParent(
     const token = tokens[i]
 
     if (Array.isArray(cur)) {
-      const idx = toIndex(token)
+      const idx = toJsonPointerArrayIndex(token)
       if (idx >= cur.length) return null
       stack.push({ container: cur, token: idx })
       cur = cur[idx]

package/src/JsonPointer.ts

@@ -1,8 +1,8 @@
 /**
- * Helpers for escaping and unescaping JSON Pointer path segments. JSON Pointer
- * uses `/` to separate path tokens inside a JSON document, so token text must
- * encode literal `~` and `/` characters. This module provides the two RFC 6901
- * token conversions used by JSON Patch and related path handling.
+ * Helpers for escaping JSON Pointer path segments and converting JSON Pointer
+ * URI fragments. JSON Pointer uses `/` to separate path tokens inside a JSON
+ * document, so token text must encode literal `~` and `/` characters. URI
+ * fragments additionally apply percent-encoding after JSON Pointer escaping.
  *
  * @since 4.0.0
  */
@@ -78,3 +78,96 @@ export function escapeToken(token: string): string {
 export function unescapeToken(token: string): string {
   return token.replace(/~1/g, "/").replace(/~0/g, "~");
 }
+
+/** @internal */
+export function formatUriFragmentToken(token: string): string {
+  return encodeURI(escapeToken(token)).replace(/#/g, "%23");
+}
+
+/** @internal */
+export function decodeUriFragment(fragment: string): string | undefined {
+  if (fragment.length === 0 || fragment === "#") return ""
+  if (!fragment.startsWith("#")) return undefined
+  const encoded = fragment.slice(1)
+  try {
+    if (encodeURI(encoded).replace(/%25/g, "%").replace(/#/g, "%23") !== encoded) return undefined
+    const pointer = decodeURIComponent(encoded)
+    return pointer.startsWith("/") && !/~(?:[^01]|$)/.test(pointer) ? pointer : undefined;
+  } catch {
+    return undefined
+  }
+}
+
+/**
+ * Parses a JSON Pointer URI fragment into decoded path tokens.
+ *
+ * **When to use**
+ *
+ * Use when you need to resolve a URI fragment against a JSON document.
+ *
+ * **Details**
+ *
+ * Percent-encoding is decoded before the pointer is split into tokens, then
+ * each token is decoded with {@link unescapeToken}. The empty string and `#`
+ * both represent the document root.
+ *
+ * **Gotchas**
+ *
+ * Returns `undefined` when the input is not a URI fragment, contains characters
+ * that require percent-encoding, or contains an invalid JSON Pointer escape
+ * sequence.
+ *
+ * **Example** (Parsing URI fragments)
+ *
+ * ```ts import.meta.vitest
+ * import { JsonPointer } from "effect"
+ *
+ * JsonPointer.parseUriFragment("#/users/a~1b") // => ["users", "a/b"]
+ * JsonPointer.parseUriFragment("#/caf%C3%A9") // => ["café"]
+ * JsonPointer.parseUriFragment("#/%") // => undefined
+ * JsonPointer.parseUriFragment("#/a#b") // => undefined
+ * ```
+ *
+ * @see {@link formatUriFragment} for the inverse operation
+ * @category decoding
+ * @since 4.0.0
+ */
+export function parseUriFragment(fragment: string): ReadonlyArray<string> | undefined {
+  const pointer = decodeUriFragment(fragment)
+  return pointer === undefined ? undefined : pointer.length === 0 ? [] : pointer.slice(1).split("/").map(unescapeToken)
+}
+
+/**
+ * Formats path tokens as a JSON Pointer URI fragment.
+ *
+ * **When to use**
+ *
+ * Use when you need a URI fragment that identifies a value in a JSON document.
+ *
+ * **Details**
+ *
+ * Each token is encoded with {@link escapeToken} before URI percent-encoding
+ * is applied. An empty path is formatted as `#`.
+ *
+ * **Gotchas**
+ *
+ * Throws a `URIError` when a token contains an unpaired surrogate.
+ *
+ * **Example** (Formatting a URI fragment)
+ *
+ * ```ts import.meta.vitest
+ * import { JsonPointer } from "effect"
+ *
+ * JsonPointer.formatUriFragment(["users", "a/b", "Rate%"]) // => "#/users/a~1b/Rate%25"
+ * ```
+ *
+ * @see {@link parseUriFragment} for the inverse operation
+ * @category encoding
+ * @since 4.0.0
+ */
+export function formatUriFragment(path: ReadonlyArray<string>): string {
+  return path.reduce(
+    (fragment, token) => `${fragment}/${formatUriFragmentToken(token)}`,
+    "#"
+  )
+}

package/src/JsonSchema.ts

@@ -9,7 +9,7 @@
  * @since 4.0.0
  */
 import * as InternalRecord from "./internal/record.ts"
-import { escapeToken, unescapeToken } from "./JsonPointer.ts"
+import { formatUriFragment, parseUriFragment } from "./JsonPointer.ts"
 import * as Predicate from "./Predicate.ts"
 
 /**
@@ -218,9 +218,9 @@ function isMetaSchemaUri(value: unknown, uri: string): boolean {
 }
 
 function rewriteOpenApiComponentsReference(reference: string): string {
-  const path = reference.startsWith("#") ? parsePointerFragment(reference) : undefined
+  const path = reference.startsWith("#") ? parseUriFragment(reference) : undefined
   return path !== undefined && path[0] === "components" && path[1] === "schemas"
-    ? formatPointerFragment(["$defs", ...path.slice(2)])
+    ? formatUriFragment(["$defs", ...path.slice(2)])
     : reference
 }
 
@@ -627,7 +627,7 @@ export function toMultiDocumentOpenApi3_1(multiDocument: MultiDocument<"draft-20
     return transformSchema(schema, (schema, inEmbeddedResource) => {
       rejectKeywordCollisions(schema, OPEN_API_31_TARGET_COLLISIONS, "OpenAPI 3.1", "Draft 2020-12")
       rewriteSchemaRef(schema, (reference, keyword) => {
-        const path = reference.startsWith("#") ? parsePointerFragment(reference) : undefined
+        const path = reference.startsWith("#") ? parseUriFragment(reference) : undefined
         if (path === undefined || path[0] !== "$defs" || path.length < 2) return reference
         const key = path[1]
         if (isRootResource) {
@@ -643,7 +643,7 @@ export function toMultiDocumentOpenApi3_1(multiDocument: MultiDocument<"draft-20
         }
         return inEmbeddedResource
           ? reference
-          : formatPointerFragment(["components", "schemas", keyMap.get(key) ?? key, ...path.slice(2)])
+          : formatUriFragment(["components", "schemas", keyMap.get(key) ?? key, ...path.slice(2)])
       })
     }) as JsonSchema
   }
@@ -682,7 +682,7 @@ export function sanitizeOpenApiComponentsSchemasKey(s: string): string {
 
 /** @internal */
 export function getReferenceKey($ref: string): string | undefined {
-  const path = $ref.startsWith("#") ? parsePointerFragment($ref) : undefined
+  const path = $ref.startsWith("#") ? parseUriFragment($ref) : undefined
   return path !== undefined && path.length === 2 && path[0] === "$defs"
     ? path[1]
     : undefined
@@ -815,7 +815,7 @@ function runConverter<A>(adapter: Adapter, options: ConverterOptions | undefined
       let reference = value
       const resolved = resolveUrl(value, sourceResource)
       if (resolved !== undefined) {
-        const sourcePointer = parsePointerFragment(resolved.hash)
+        const sourcePointer = parseUriFragment(resolved.hash)
         resolved.hash = ""
         if (sourcePointer !== undefined) {
           const targetPath = locations.get(locationKey(resolved.href, sourcePointer))
@@ -927,29 +927,11 @@ function resolveResourceUri(value: unknown, base: string): string | undefined {
   return url.href
 }
 
-function parsePointerFragment(hash: string): Path | undefined {
-  if (hash.length === 0) return []
-  let pointer: string
-  try {
-    pointer = decodeURIComponent(hash.slice(1))
-  } catch {
-    return undefined
-  }
-  if (!pointer.startsWith("/")) return undefined
-  return /~(?:[^01]|$)/.test(pointer) ? undefined : pointer.slice(1).split("/").map(unescapeToken);
-}
-
 function relocateReference(reference: string, targetPath: Path): string {
   const index = reference.indexOf("#")
   if (index === -1 && targetPath.length === 0) return reference
   const uri = index === -1 ? reference : reference.slice(0, index)
-  return `${uri}${formatPointerFragment(targetPath)}`
-}
-
-function formatPointerFragment(path: Path): string {
-  return path.length === 0
-    ? "#"
-    : `#/${path.map((token) => encodeURI(escapeToken(token)).replace(/#/g, "%23")).join("/")}`;
+  return `${uri}${formatUriFragment(targetPath)}`
 }
 
 function locationKey(resource: string, pointer: Path): string {

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

@@ -423,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>
@@ -431,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>>
@@ -443,7 +445,7 @@ export const Service = <Self>() =>
   TagClass.key = id
   Object.defineProperty(TagClass, "stack", {
     get() {
-      return creationError.stack
+      return creationError?.stack
     }
   })
 

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))