effect 4.0.0-beta.11 → 4.0.0-beta.13

package/src/Config.ts

@@ -886,18 +886,19 @@ export function schema<T, E>(codec: Schema.Codec<T, E>, path?: string | ConfigPr
   const decodeUnknownEffect = Parser.decodeUnknownEffect(toCodecStringTree)
   const toCodecStringTreeEncoded = AST.toEncoded(toCodecStringTree.ast)
   const defaultPath = typeof path === "string" ? [path] : path ?? []
-  return make((provider) =>
-    recur(toCodecStringTreeEncoded, provider, defaultPath).pipe(
+  return make((provider) => {
+    const path = provider.prefix ? [...provider.prefix, ...defaultPath] : defaultPath
+    return recur(toCodecStringTreeEncoded, provider, defaultPath).pipe(
       Effect.flatMapEager((tree) =>
-        decodeUnknownEffect(tree).pipe(Effect.mapErrorEager((issue) =>
-          new Schema.SchemaError(defaultPath.length > 0 ? new Issue.Pointer(defaultPath, issue) : issue)
-        ))
+        decodeUnknownEffect(tree).pipe(
+          Effect.mapErrorEager((issue) =>
+            new Schema.SchemaError(path.length > 0 ? new Issue.Pointer(path, issue) : issue)
+          )
+        )
       ),
-      Effect.mapErrorEager((cause) =>
-        new ConfigError(cause)
-      )
+      Effect.mapErrorEager((cause) => new ConfigError(cause))
     )
-  )
+  })
 }
 
 /** @internal */
@@ -1446,3 +1447,164 @@ export function url(name?: string) {
 export function date(name?: string) {
   return schema(Schema.DateValid, name)
 }
+
+/**
+ * Scopes a config under a named prefix.
+ *
+ * When to use:
+ * - Grouping related config keys under a common namespace (e.g.
+ *   `"database"`, `"redis"`).
+ * - Building reusable config fragments that callers nest at different paths.
+ *
+ * The prefix is prepended to every key the inner config reads. With
+ * `fromUnknown` this means an extra object level; with `fromEnv` it means
+ * a `_`-separated prefix on env var names.
+ *
+ * Multiple `nested` calls compose: the outermost name becomes the
+ * outermost path segment.
+ *
+ * **Example** (Nesting a struct config under `"database"`)
+ *
+ * ```ts
+ * import { Config, ConfigProvider, Effect } from "effect"
+ *
+ * const dbConfig = Config.all({
+ *   host: Config.string("host"),
+ *   port: Config.number("port")
+ * }).pipe(Config.nested("database"))
+ *
+ * const provider = ConfigProvider.fromUnknown({
+ *   database: { host: "localhost", port: "5432" }
+ * })
+ * // Effect.runSync(dbConfig.parse(provider))
+ * // { host: "localhost", port: 5432 }
+ * ```
+ *
+ * **Example** (Env vars with nested prefix)
+ *
+ * ```ts
+ * import { Config, ConfigProvider, Effect } from "effect"
+ *
+ * const host = Config.string("host").pipe(Config.nested("database"))
+ *
+ * const provider = ConfigProvider.fromEnv({
+ *   env: { database_host: "localhost" }
+ * })
+ * // Effect.runSync(host.parse(provider)) // "localhost"
+ * ```
+ *
+ * @see {@link all} – combine multiple configs into a struct
+ * @see {@link schema} – read structured config from a schema
+ *
+ * @category Combinators
+ * @since 4.0.0
+ */
+export const nested: {
+  /**
+   * Scopes a config under a named prefix.
+   *
+   * When to use:
+   * - Grouping related config keys under a common namespace (e.g.
+   *   `"database"`, `"redis"`).
+   * - Building reusable config fragments that callers nest at different paths.
+   *
+   * The prefix is prepended to every key the inner config reads. With
+   * `fromUnknown` this means an extra object level; with `fromEnv` it means
+   * a `_`-separated prefix on env var names.
+   *
+   * Multiple `nested` calls compose: the outermost name becomes the
+   * outermost path segment.
+   *
+   * **Example** (Nesting a struct config under `"database"`)
+   *
+   * ```ts
+   * import { Config, ConfigProvider, Effect } from "effect"
+   *
+   * const dbConfig = Config.all({
+   *   host: Config.string("host"),
+   *   port: Config.number("port")
+   * }).pipe(Config.nested("database"))
+   *
+   * const provider = ConfigProvider.fromUnknown({
+   *   database: { host: "localhost", port: "5432" }
+   * })
+   * // Effect.runSync(dbConfig.parse(provider))
+   * // { host: "localhost", port: 5432 }
+   * ```
+   *
+   * **Example** (Env vars with nested prefix)
+   *
+   * ```ts
+   * import { Config, ConfigProvider, Effect } from "effect"
+   *
+   * const host = Config.string("host").pipe(Config.nested("database"))
+   *
+   * const provider = ConfigProvider.fromEnv({
+   *   env: { database_host: "localhost" }
+   * })
+   * // Effect.runSync(host.parse(provider)) // "localhost"
+   * ```
+   *
+   * @see {@link all} – combine multiple configs into a struct
+   * @see {@link schema} – read structured config from a schema
+   *
+   * @category Combinators
+   * @since 4.0.0
+   */
+  (name: string): <A>(self: Config<A>) => Config<A>
+  /**
+   * Scopes a config under a named prefix.
+   *
+   * When to use:
+   * - Grouping related config keys under a common namespace (e.g.
+   *   `"database"`, `"redis"`).
+   * - Building reusable config fragments that callers nest at different paths.
+   *
+   * The prefix is prepended to every key the inner config reads. With
+   * `fromUnknown` this means an extra object level; with `fromEnv` it means
+   * a `_`-separated prefix on env var names.
+   *
+   * Multiple `nested` calls compose: the outermost name becomes the
+   * outermost path segment.
+   *
+   * **Example** (Nesting a struct config under `"database"`)
+   *
+   * ```ts
+   * import { Config, ConfigProvider, Effect } from "effect"
+   *
+   * const dbConfig = Config.all({
+   *   host: Config.string("host"),
+   *   port: Config.number("port")
+   * }).pipe(Config.nested("database"))
+   *
+   * const provider = ConfigProvider.fromUnknown({
+   *   database: { host: "localhost", port: "5432" }
+   * })
+   * // Effect.runSync(dbConfig.parse(provider))
+   * // { host: "localhost", port: 5432 }
+   * ```
+   *
+   * **Example** (Env vars with nested prefix)
+   *
+   * ```ts
+   * import { Config, ConfigProvider, Effect } from "effect"
+   *
+   * const host = Config.string("host").pipe(Config.nested("database"))
+   *
+   * const provider = ConfigProvider.fromEnv({
+   *   env: { database_host: "localhost" }
+   * })
+   * // Effect.runSync(host.parse(provider)) // "localhost"
+   * ```
+   *
+   * @see {@link all} – combine multiple configs into a struct
+   * @see {@link schema} – read structured config from a schema
+   *
+   * @category Combinators
+   * @since 4.0.0
+   */
+  <A>(self: Config<A>, name: string): Config<A>
+} = dual(
+  2,
+  <A>(self: Config<A>, name: string): Config<A> => make((provider) => self.parse(ConfigProvider.nested(provider, name)))
+)

package/src/Effect.ts

@@ -20846,6 +20846,86 @@ export const annotateLogs = dual<
     })
 )
 
+/**
+ * Adds log annotations to the current scope.
+ *
+ * This differs from `annotateLogs`, which only annotates a specific effect.
+ * `annotateLogsScoped` updates annotations for the entire current `Scope` and
+ * restores the previous annotations when the scope closes.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ *
+ * const program = Effect.scoped(
+ *   Effect.gen(function*() {
+ *     yield* Effect.log("before")
+ *     yield* Effect.annotateLogsScoped({ requestId: "req-123" })
+ *     yield* Effect.log("inside scope")
+ *   })
+ * )
+ *
+ * Effect.runPromise(program)
+ * ```
+ *
+ * @since 4.0.0
+ * @category Logging
+ */
+export const annotateLogsScoped: {
+  /**
+   * Adds log annotations to the current scope.
+   *
+   * This differs from `annotateLogs`, which only annotates a specific effect.
+   * `annotateLogsScoped` updates annotations for the entire current `Scope` and
+   * restores the previous annotations when the scope closes.
+   *
+   * @example
+   * ```ts
+   * import { Effect } from "effect"
+   *
+   * const program = Effect.scoped(
+   *   Effect.gen(function*() {
+   *     yield* Effect.log("before")
+   *     yield* Effect.annotateLogsScoped({ requestId: "req-123" })
+   *     yield* Effect.log("inside scope")
+   *   })
+   * )
+   *
+   * Effect.runPromise(program)
+   * ```
+   *
+   * @since 4.0.0
+   * @category Logging
+   */
+  (key: string, value: unknown): Effect<void, never, Scope>
+  /**
+   * Adds log annotations to the current scope.
+   *
+   * This differs from `annotateLogs`, which only annotates a specific effect.
+   * `annotateLogsScoped` updates annotations for the entire current `Scope` and
+   * restores the previous annotations when the scope closes.
+   *
+   * @example
+   * ```ts
+   * import { Effect } from "effect"
+   *
+   * const program = Effect.scoped(
+   *   Effect.gen(function*() {
+   *     yield* Effect.log("before")
+   *     yield* Effect.annotateLogsScoped({ requestId: "req-123" })
+   *     yield* Effect.log("inside scope")
+   *   })
+   * )
+   *
+   * Effect.runPromise(program)
+   * ```
+   *
+   * @since 4.0.0
+   * @category Logging
+   */
+  (values: Record<string, unknown>): Effect<void, never, Scope>
+} = internal.annotateLogsScoped
+
 /**
  * Adds a span to each log line in this effect.
  *

package/src/Fiber.ts

@@ -338,7 +338,10 @@ export const interruptAs: {
    * @since 2.0.0
    * @category interruption
    */
-  (fiberId: number): <A, E>(self: Fiber<A, E>) => Effect<void>
+  (
+    fiberId: number | undefined,
+    annotations?: ServiceMap.ServiceMap<never> | undefined
+  ): <A, E>(self: Fiber<A, E>) => Effect<void>
   /**
    * Interrupts a fiber with a specific fiber ID as the interruptor. This allows
    * tracking which fiber initiated the interruption.
@@ -361,7 +364,11 @@ export const interruptAs: {
    * @since 2.0.0
    * @category interruption
    */
-  <A, E>(self: Fiber<A, E>, fiberId: number): Effect<void>
+  <A, E>(
+    self: Fiber<A, E>,
+    fiberId: number | undefined,
+    annotations?: ServiceMap.ServiceMap<never> | undefined
+  ): Effect<void>
 } = effect.fiberInterruptAs
 
 /**

package/src/Graph.ts

@@ -2529,13 +2529,23 @@ export interface MermaidOptions<N, E> {
  * Escapes special characters in labels for Mermaid syntax compatibility.
  */
 const escapeMermaidLabel = (label: string): string => {
+  // Escape special characters for Mermaid using HTML entity codes
+  // According to: https://mermaid.js.org/syntax/flowchart.html#special-characters-that-break-syntax
   return label
-    .replace(/\\/g, "\\\\") // Escape backslashes first
-    .replace(/"/g, "\\\"") // Escape quotes
-    .replace(/\[/g, "\\[") // Escape square brackets
-    .replace(/\]/g, "\\]") // Escape square brackets
-    .replace(/\|/g, "\\|") // Escape pipes
-    .replace(/\n/g, "<br/>"); // Convert newlines to HTML breaks
+    .replace(/#/g, "#35;")
+    .replace(/"/g, "#quot;")
+    .replace(/</g, "#lt;")
+    .replace(/>/g, "#gt;")
+    .replace(/&/g, "#amp;")
+    .replace(/\[/g, "#91;")
+    .replace(/\]/g, "#93;")
+    .replace(/\{/g, "#123;")
+    .replace(/\}/g, "#125;")
+    .replace(/\(/g, "#40;")
+    .replace(/\)/g, "#41;")
+    .replace(/\|/g, "#124;")
+    .replace(/\\/g, "#92;")
+    .replace(/\n/g, "<br/>");
 }
 
 /**

package/src/ManagedRuntime.ts

@@ -140,7 +140,7 @@ export interface ManagedRuntime<in R, out ER> {
  * class Notifications extends ServiceMap.Service<Notifications, {
  *   readonly notify: (message: string) => Effect.Effect<void>
  * }>()("Notifications") {
- *   static layer = Layer.succeed(this)({
+ *   static readonly layer = Layer.succeed(this)({
  *     notify: (message) => Console.log(message)
  *   })
  * }

package/src/Random.ts

@@ -76,6 +76,24 @@ const randomWith = <A>(f: (random: typeof Random["Service"]) => A): Effect.Effec
  */
 export const next: Effect.Effect<number> = randomWith((r) => r.nextDoubleUnsafe())
 
+/**
+ * Generates a random boolean value.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Random } from "effect"
+ *
+ * const program = Effect.gen(function*() {
+ *   const value = yield* Random.nextBoolean
+ *   console.log("Random boolean:", value)
+ * })
+ * ```
+ *
+ * @since 4.0.0
+ * @category Random Number Generators
+ */
+export const nextBoolean: Effect.Effect<boolean> = randomWith((r) => r.nextDoubleUnsafe() > 0.5)
+
 /**
  * Generates a random integer between `Number.MIN_SAFE_INTEGER` (inclusive)
  * and `Number.MAX_SAFE_INTEGER` (inclusive).

package/src/Schedule.ts

@@ -4015,7 +4015,7 @@ export const fixed = (interval: Duration.Input): Schedule<number> => {
   return fromStepWithMetadata(effect.succeed((meta) =>
     effect.succeed([
       meta.attempt - 1,
-      window === 0 || meta.elapsedSincePrevious > window
+      window === 0
         ? Duration.zero
         : Duration.millis(window - (meta.elapsed % window))
     ])

package/src/Schema.ts

@@ -1717,7 +1717,7 @@ export function fieldsAssign<const NewFields extends Struct.Fields>(fields: NewF
  * @since 4.0.0
  */
 export function encodeKeys<
-  S extends Struct<Struct.Fields>,
+  S extends Top & { readonly fields: Struct.Fields },
   const M extends { readonly [K in keyof S["fields"]]?: PropertyKey }
 >(mapping: M) {
   return function(

package/src/SchemaAST.ts

@@ -594,7 +594,7 @@ export class Declaration extends Base {
   }
   /** @internal */
   getExpected(): string {
-    const expected = this.annotations?.identifier ?? this.annotations?.expected
+    const expected = this.annotations?.expected
     if (typeof expected === "string") return expected
     return "<Declaration>"
   }

package/src/index.ts

@@ -1120,6 +1120,53 @@ export * as Equal from "./Equal.ts"
 export * as Equivalence from "./Equivalence.ts"
 
 /**
+ * Pluggable error reporting for Effect programs.
+ *
+ * Reporting is triggered by `Effect.withErrorReporting`,
+ * `ErrorReporter.report`, or built-in reporting boundaries in the HTTP and
+ * RPC server modules.
+ *
+ * Each reporter receives a structured callback with the failing `Cause`, a
+ * pretty-printed `Error`, severity, and any extra attributes attached to the
+ * original error — making it straightforward to forward failures to Sentry,
+ * Datadog, or a custom logging backend.
+ *
+ * Use the annotation symbols (`ignore`, `severity`, `attributes`) on your
+ * error classes to control reporting behavior per-error.
+ *
+ * @example
+ * ```ts
+ * import { Data, Effect, ErrorReporter } from "effect"
+ *
+ * // A reporter that logs to the console
+ * const consoleReporter = ErrorReporter.make(({ error, severity }) => {
+ *   console.error(`[${severity}]`, error.message)
+ * })
+ *
+ * // An error that should be ignored by reporters
+ * class NotFoundError extends Data.TaggedError("NotFoundError")<{}> {
+ *   readonly [ErrorReporter.ignore] = true
+ * }
+ *
+ * // An error with custom severity and attributes
+ * class RateLimitError extends Data.TaggedError("RateLimitError")<{
+ *   readonly retryAfter: number
+ * }> {
+ *   readonly [ErrorReporter.severity] = "Warn" as const
+ *   readonly [ErrorReporter.attributes] = {
+ *     retryAfter: this.retryAfter
+ *   }
+ * }
+ *
+ * // Opt in to error reporting with Effect.withErrorReporting
+ * const program = Effect.gen(function*() {
+ *   yield* new RateLimitError({ retryAfter: 60 })
+ * }).pipe(
+ *   Effect.withErrorReporting,
+ *   Effect.provide(ErrorReporter.layer([consoleReporter]))
+ * )
+ * ```
+ *
  * @since 4.0.0
  */
 export * as ErrorReporter from "./ErrorReporter.ts"

package/src/internal/effect.ts

@@ -492,33 +492,33 @@ const fiberIdStore = { id: 0 }
 export const getCurrentFiber = (): Fiber.Fiber<any, any> | undefined => (globalThis as any)[currentFiberTypeId]
 
 const keepAlive = (() => {
-  const start = (() => {
-    const setInterval = globalThis.setInterval
-    const clearInterval = globalThis.clearInterval
+  let isAvailable: boolean | undefined
+  const start = () => {
+    if (isAvailable === true) return setInterval(constVoid, 2_147_483_647)
+    else if (isAvailable === false) return undefined
+
     try {
       const running = setInterval(constVoid, 2_147_483_647)
-      clearInterval(running)
-      return {
-        setInterval,
-        clearInterval
-      }
+      isAvailable = true
+      return running
     } catch {
+      isAvailable = false
       return undefined
     }
-  })()
+  }
   let count = 0
   let running: ReturnType<typeof globalThis.setInterval> | undefined = undefined
   return ({
     increment() {
       count++
-      if (start !== undefined && running === undefined) {
-        running = start.setInterval(constVoid, 2_147_483_647)
+      if (running === undefined) {
+        running = start()
       }
     },
     decrement() {
       count--
-      if (count === 0 && start !== undefined && running !== undefined) {
-        start.clearInterval(running)
+      if (count === 0 && running !== undefined) {
+        clearInterval(running)
         running = undefined
       }
     }
@@ -832,13 +832,29 @@ export const fiberInterrupt = <A, E>(
 
 /** @internal */
 export const fiberInterruptAs: {
-  (fiberId: number): <A, E>(self: Fiber.Fiber<A, E>) => Effect.Effect<void>
-  <A, E>(self: Fiber.Fiber<A, E>, fiberId: number): Effect.Effect<void>
-} = dual(2, <A, E>(self: Fiber.Fiber<A, E>, fiberId: number): Effect.Effect<void> =>
-  withFiber((parent) => {
-    self.interruptUnsafe(fiberId, fiberStackAnnotations(parent))
-    return asVoid(fiberAwait(self))
-  }))
+  (
+    fiberId: number | undefined,
+    annotations?: ServiceMap.ServiceMap<never> | undefined
+  ): <A, E>(self: Fiber.Fiber<A, E>) => Effect.Effect<void>
+  <A, E>(
+    self: Fiber.Fiber<A, E>,
+    fiberId: number | undefined,
+    annotations?: ServiceMap.ServiceMap<never> | undefined
+  ): Effect.Effect<void>
+} = dual(
+  (args) => hasProperty(args[0], FiberTypeId),
+  <A, E>(
+    self: Fiber.Fiber<A, E>,
+    fiberId: number | undefined,
+    annotations?: ServiceMap.ServiceMap<never> | undefined
+  ): Effect.Effect<void> =>
+    withFiber((parent) => {
+      let ann = fiberStackAnnotations(parent)
+      ann = ann && annotations ? ServiceMap.merge(ann, annotations) : ann ?? annotations
+      self.interruptUnsafe(fiberId, ann)
+      return asVoid(fiberAwait(self))
+    })
+)
 
 /** @internal */
 export const fiberInterruptAll = <A extends Iterable<Fiber.Fiber<any, any>>>(
@@ -2003,23 +2019,8 @@ export const updateServices: {
       const nextServices = f(prev)
       if (prev === nextServices) return self as any
       fiber.setServices(nextServices)
-      const newServices = new Map<string, unknown>()
-      for (const [key, value] of fiber.services.mapUnsafe) {
-        if (!prev.mapUnsafe.has(key) || value !== prev.mapUnsafe.get(key)) {
-          newServices.set(key, value)
-        }
-      }
-      return onExitPrimitive(self as any, () => {
-        const map = new Map(fiber.services.mapUnsafe)
-        for (const [key, value] of newServices) {
-          if (value !== map.get(key)) continue
-          if (prev.mapUnsafe.has(key)) {
-            map.set(key, prev.mapUnsafe.get(key))
-          } else {
-            map.delete(key)
-          }
-        }
-        fiber.setServices(ServiceMap.makeUnsafe(map))
+      return onExitPrimitive(self, () => {
+        fiber.setServices(prev)
         return undefined
       })
     })
@@ -2043,12 +2044,11 @@ export const updateService: {
     service: ServiceMap.Service<I, A>,
     f: (value: A) => A
   ): Effect.Effect<XA, E, R | I> =>
-    withFiber((fiber) => {
-      const prev = ServiceMap.getUnsafe(fiber.services, service)
+    updateServices(self, (s) => {
+      const prev = ServiceMap.getUnsafe(s, service)
       const next = f(prev)
-      if (prev === next) return self
-      fiber.setServices(ServiceMap.add(fiber.services, service, next))
-      return onExit(self, () => sync(() => fiber.setServices(ServiceMap.add(fiber.services, service, prev))))
+      if (prev === next) return s
+      return ServiceMap.add(s, service, next)
     })
 )
 
@@ -2115,11 +2115,10 @@ const provideServiceImpl = <A, E, R, I, S>(
   service: ServiceMap.Service<I, S>,
   implementation: S
 ): Effect.Effect<A, E, Exclude<R, I>> =>
-  withFiber((fiber) => {
-    const prev = ServiceMap.getOption(fiber.services, service)
-    if (prev._tag === "Some" && prev.value === implementation) return self
-    fiber.setServices(ServiceMap.add(fiber.services, service, implementation))
-    return onExit(self, () => sync(() => fiber.setServices(ServiceMap.addOrOmit(fiber.services, service, prev))))
+  updateServices(self, (s) => {
+    const prev = s.mapUnsafe.get(service.key)
+    if (prev === implementation) return s
+    return ServiceMap.add(s, service, implementation)
   }) as any
 
 /** @internal */
@@ -3666,11 +3665,11 @@ export const provideScope: {
 /** @internal */
 export const scoped = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, Exclude<R, Scope.Scope>> =>
   withFiber((fiber) => {
-    const prev = ServiceMap.getOption(fiber.services, scopeTag)
+    const prev = fiber.services
     const scope = scopeMakeUnsafe()
     fiber.setServices(ServiceMap.add(fiber.services, scopeTag, scope))
     return onExitPrimitive(self, (exit) => {
-      fiber.setServices(ServiceMap.addOrOmit(fiber.services, scopeTag, prev))
+      fiber.setServices(prev)
       return scopeCloseUnsafe(scope, exit)
     })
   }) as any
@@ -5555,6 +5554,40 @@ export const LogToStderr = ServiceMap.Reference<boolean>("effect/Logger/LogToStd
   defaultValue: constFalse
 })
 
+/** @internal */
+export const annotateLogsScoped: {
+  (key: string, value: unknown): Effect.Effect<void, never, Scope.Scope>
+  (values: Record<string, unknown>): Effect.Effect<void, never, Scope.Scope>
+} = function() {
+  const entries = typeof arguments[0] === "string" ?
+    [[arguments[0], arguments[1]]] :
+    Object.entries(arguments[0])
+  return uninterruptible(withFiber((fiber) => {
+    const prev = fiber.getRef(CurrentLogAnnotations)
+    const next = { ...prev }
+    for (let i = 0; i < entries.length; i++) {
+      const [key, value] = entries[i]
+      next[key] = value
+    }
+    fiber.setServices(ServiceMap.add(fiber.services, CurrentLogAnnotations, next))
+    return scopeAddFinalizerExit(ServiceMap.getUnsafe(fiber.services, scopeTag), (_) => {
+      const current = fiber.getRef(CurrentLogAnnotations)
+      const next = { ...current }
+      for (let i = 0; i < entries.length; i++) {
+        const [key, value] = entries[i]
+        if (current[key] !== value) continue
+        if (key in prev) {
+          next[key] = prev[key]
+        } else {
+          delete next[key]
+        }
+      }
+      fiber.setServices(ServiceMap.add(fiber.services, CurrentLogAnnotations, next))
+      return void_
+    })
+  }))
+}
+
 /** @internal */
 export const LoggerTypeId = "~effect/Logger"
 

package/src/internal/request.ts

@@ -159,7 +159,7 @@ const addEntry = <A extends Request.Any>(
       batch = newBatch
     }
     batchMap.set(key, batch)
-    batch.fiber = effect.runFork(batch.delayEffect, { scheduler: fiber.currentScheduler })
+    batch.fiber = effect.runForkWith(fiber.services)(batch.delayEffect, { scheduler: fiber.currentScheduler })
   }
 
   batch.entrySet.add(entry)
@@ -167,7 +167,7 @@ const addEntry = <A extends Request.Any>(
   if (batch.resolver.collectWhile(batch.entries)) return entry
 
   batch.fiber!.interruptUnsafe(fiber.id)
-  batch.fiber = effect.runFork(runBatch(batch), { scheduler: fiber.currentScheduler })
+  batch.fiber = effect.runForkWith(fiber.services)(runBatch(batch), { scheduler: fiber.currentScheduler })
   return entry
 }
 

package/src/internal/schema/annotations.ts

@@ -26,6 +26,8 @@ export const resolveBrands = resolveAt<ReadonlyArray<string>>("brands")
 
 /** @internal */
 export const getExpected = memoize((ast: AST.AST): string => {
+  const identifier = resolveIdentifier(ast)
+  if (typeof identifier === "string") return identifier
   return ast.getExpected(getExpected)
 })