effect 3.11.8 → 3.11.10

package/src/SchemaAST.ts

@@ -1096,7 +1096,7 @@ export class Enums implements Annotated {
  */
 export const isEnums: (ast: AST) => ast is Enums = createASTGuard("Enums")
 
-type TemplateLiteralSpanBaseType = StringKeyword | NumberKeyword | Literal
+type TemplateLiteralSpanBaseType = StringKeyword | NumberKeyword | Literal | TemplateLiteral
 
 type TemplateLiteralSpanType = TemplateLiteralSpanBaseType | Union<TemplateLiteralSpanType>
 
@@ -1105,6 +1105,7 @@ const isTemplateLiteralSpanType = (ast: AST): ast is TemplateLiteralSpanType =>
     case "Literal":
     case "NumberKeyword":
     case "StringKeyword":
+    case "TemplateLiteral":
       return true
     case "Union":
       return ast.types.every(isTemplateLiteralSpanType)
@@ -1120,6 +1121,8 @@ const templateLiteralSpanUnionTypeToString = (type: TemplateLiteralSpanType): st
       return "string"
     case "NumberKeyword":
       return "number"
+    case "TemplateLiteral":
+      return String(type)
     case "Union":
       return type.types.map(templateLiteralSpanUnionTypeToString).join(" | ")
   }
@@ -1133,6 +1136,8 @@ const templateLiteralSpanTypeToString = (type: TemplateLiteralSpanType): string
       return "${string}"
     case "NumberKeyword":
       return "${number}"
+    case "TemplateLiteral":
+      return "${" + String(type) + "}"
     case "Union":
       return "${" + type.types.map(templateLiteralSpanUnionTypeToString).join(" | ") + "}"
   }
@@ -1792,7 +1797,12 @@ export class Refinement<From extends AST = AST> implements Annotated {
    * @since 3.10.0
    */
   toString() {
-    return Option.getOrElse(getExpected(this), () => `{ ${this.from} | filter }`)
+    return getIdentifierAnnotation(this).pipe(Option.getOrElse(() =>
+      Option.match(getOrElseExpected(this), {
+        onNone: () => `{ ${this.from} | filter }`,
+        onSome: (expected) => isRefinement(this.from) ? String(this.from) + " & " + expected : expected
+      })
+    ))
   }
   /**
    * @since 3.10.0
@@ -2093,72 +2103,75 @@ export const keyof = (ast: AST): AST => Union.unify(_keyof(ast))
 const STRING_KEYWORD_PATTERN = ".*"
 const NUMBER_KEYWORD_PATTERN = "[+-]?\\d*\\.?\\d+(?:[Ee][+-]?\\d+)?"
 
-const getTemplateLiteralPattern = (type: TemplateLiteralSpanType): string => {
+const getTemplateLiteralSpanTypePattern = (type: TemplateLiteralSpanType, capture: boolean): string => {
   switch (type._tag) {
+    case "Literal":
+      return regexp.escape(String(type.literal))
     case "StringKeyword":
       return STRING_KEYWORD_PATTERN
     case "NumberKeyword":
       return NUMBER_KEYWORD_PATTERN
-    case "Literal":
-      return regexp.escape(String(type.literal))
+    case "TemplateLiteral":
+      return getTemplateLiteralPattern(type, capture, false)
     case "Union":
-      return type.types.map(getTemplateLiteralPattern).join("|")
+      return type.types.map((type) => getTemplateLiteralSpanTypePattern(type, capture)).join("|")
   }
 }
 
-/**
- * @since 3.10.0
- */
-export const getTemplateLiteralRegExp = (ast: TemplateLiteral): RegExp => {
-  let pattern = `^`
+const handleTemplateLiteralSpanTypeParens = (
+  type: TemplateLiteralSpanType,
+  s: string,
+  capture: boolean,
+  top: boolean
+) => {
+  if (isUnion(type)) {
+    if (capture && !top) {
+      return `(?:${s})`
+    }
+  } else if (!capture || !top) {
+    return s
+  }
+  return `(${s})`
+}
+
+const getTemplateLiteralPattern = (ast: TemplateLiteral, capture: boolean, top: boolean): string => {
+  let pattern = ``
   if (ast.head !== "") {
-    pattern += regexp.escape(ast.head)
+    const head = regexp.escape(ast.head)
+    pattern += capture && top ? `(${head})` : head
   }
 
   for (const span of ast.spans) {
-    const p = getTemplateLiteralPattern(span.type)
-    pattern += isUnion(span.type) ? `(${p})` : p
+    const spanPattern = getTemplateLiteralSpanTypePattern(span.type, capture)
+    pattern += handleTemplateLiteralSpanTypeParens(span.type, spanPattern, capture, top)
     if (span.literal !== "") {
-      pattern += regexp.escape(span.literal)
+      const literal = regexp.escape(span.literal)
+      pattern += capture && top ? `(${literal})` : literal
     }
   }
 
-  pattern += "$"
-  return new RegExp(pattern)
-}
-
-const getTemplateLiteralCapturingPattern = (type: TemplateLiteralSpanType): string => {
-  switch (type._tag) {
-    case "StringKeyword":
-      return STRING_KEYWORD_PATTERN
-    case "NumberKeyword":
-      return NUMBER_KEYWORD_PATTERN
-    case "Literal":
-      return regexp.escape(String(type.literal))
-    case "Union":
-      return type.types.map(getTemplateLiteralCapturingPattern).join("|")
-  }
+  return pattern
 }
 
 /**
+ * Generates a regular expression from a `TemplateLiteral` AST node.
+ *
+ * @see {@link getTemplateLiteralCapturingRegExp} for a variant that captures the pattern.
+ *
  * @since 3.10.0
  */
-export const getTemplateLiteralCapturingRegExp = (ast: TemplateLiteral): RegExp => {
-  let pattern = `^`
-  if (ast.head !== "") {
-    pattern += `(${regexp.escape(ast.head)})`
-  }
+export const getTemplateLiteralRegExp = (ast: TemplateLiteral): RegExp =>
+  new RegExp(`^${getTemplateLiteralPattern(ast, false, true)}$`)
 
-  for (const span of ast.spans) {
-    pattern += `(${getTemplateLiteralCapturingPattern(span.type)})`
-    if (span.literal !== "") {
-      pattern += `(${regexp.escape(span.literal)})`
-    }
-  }
-
-  pattern += "$"
-  return new RegExp(pattern)
-}
+/**
+ * Generates a regular expression that captures the pattern defined by the given `TemplateLiteral` AST.
+ *
+ * @see {@link getTemplateLiteralRegExp} for a variant that does not capture the pattern.
+ *
+ * @since 3.10.0
+ */
+export const getTemplateLiteralCapturingRegExp = (ast: TemplateLiteral): RegExp =>
+  new RegExp(`^${getTemplateLiteralPattern(ast, true, true)}$`)
 
 /**
  * @since 3.10.0
@@ -2205,7 +2218,7 @@ export const getNumberIndexedAccess = (ast: AST): AST => {
     case "Suspend":
       return getNumberIndexedAccess(ast.f())
   }
-  throw new Error(errors_.getASTUnsupportedSchema(ast))
+  throw new Error(errors_.getASTUnsupportedSchemaErrorMessage(ast))
 }
 
 const getTypeLiteralPropertySignature = (ast: TypeLiteral, name: PropertyKey): PropertySignature | undefined => {
@@ -2274,7 +2287,7 @@ export const getPropertyKeyIndexedAccess = (ast: AST, name: PropertyKey): Proper
     case "Refinement":
       return getPropertyKeyIndexedAccess(ast.from, name)
   }
-  throw new Error(errors_.getASTUnsupportedSchema(ast))
+  throw new Error(errors_.getASTUnsupportedSchemaErrorMessage(ast))
 }
 
 const getPropertyKeys = (ast: AST): Array<PropertyKey> => {
@@ -2319,7 +2332,7 @@ export const record = (key: AST, value: AST): {
         if (Predicate.isString(key.literal) || Predicate.isNumber(key.literal)) {
           propertySignatures.push(new PropertySignature(key.literal, value, false, true))
         } else {
-          throw new Error(errors_.getASTUnsupportedLiteral(key.literal))
+          throw new Error(errors_.getASTUnsupportedLiteralErrorMessage(key.literal))
         }
         break
       case "Enums": {
@@ -2335,7 +2348,7 @@ export const record = (key: AST, value: AST): {
         key.types.forEach(go)
         break
       default:
-        throw new Error(errors_.getASTUnsupportedKeySchema(key))
+        throw new Error(errors_.getASTUnsupportedKeySchemaErrorMessage(key))
     }
   }
   go(key)
@@ -2409,7 +2422,7 @@ export const pick = (ast: AST, keys: ReadonlyArray<PropertyKey>): TypeLiteral |
       }
     }
   }
-  throw new Error(errors_.getASTUnsupportedSchema(ast))
+  throw new Error(errors_.getASTUnsupportedSchemaErrorMessage(ast))
 }
 
 /**
@@ -2452,9 +2465,8 @@ export const partial = (ast: AST, options?: { readonly exact: true }): AST => {
     case "Suspend":
       return new Suspend(() => partial(ast.f(), options))
     case "Declaration":
-      throw new Error(errors_.getASTUnsupportedSchema(ast))
     case "Refinement":
-      throw new Error(errors_.getASTUnsupportedSchema(ast))
+      throw new Error(errors_.getASTUnsupportedSchemaErrorMessage(ast))
     case "Transformation": {
       if (
         isTypeLiteralTransformation(ast.transformation) &&
@@ -2462,7 +2474,7 @@ export const partial = (ast: AST, options?: { readonly exact: true }): AST => {
       ) {
         return new Transformation(partial(ast.from, options), partial(ast.to, options), ast.transformation)
       }
-      throw new Error(errors_.getASTUnsupportedSchema(ast))
+      throw new Error(errors_.getASTUnsupportedSchemaErrorMessage(ast))
     }
   }
   return ast
@@ -2491,9 +2503,8 @@ export const required = (ast: AST): AST => {
     case "Suspend":
       return new Suspend(() => required(ast.f()))
     case "Declaration":
-      throw new Error(errors_.getASTUnsupportedSchema(ast))
     case "Refinement":
-      throw new Error(errors_.getASTUnsupportedSchema(ast))
+      throw new Error(errors_.getASTUnsupportedSchemaErrorMessage(ast))
     case "Transformation": {
       if (
         isTypeLiteralTransformation(ast.transformation) &&
@@ -2501,7 +2512,7 @@ export const required = (ast: AST): AST => {
       ) {
         return new Transformation(required(ast.from), required(ast.to), ast.transformation)
       }
-      throw new Error(errors_.getASTUnsupportedSchema(ast))
+      throw new Error(errors_.getASTUnsupportedSchemaErrorMessage(ast))
     }
   }
   return ast
@@ -2868,7 +2879,7 @@ const _keyof = (ast: AST): Array<AST> => {
     case "Transformation":
       return _keyof(ast.to)
   }
-  throw new Error(errors_.getASTUnsupportedSchema(ast))
+  throw new Error(errors_.getASTUnsupportedSchemaErrorMessage(ast))
 }
 
 /** @internal */
@@ -2920,15 +2931,59 @@ export const rename = (ast: AST, mapping: { readonly [K in PropertyKey]?: Proper
     case "Transformation":
       return compose(ast, rename(typeAST(ast), mapping))
   }
-  throw new Error(errors_.getASTUnsupportedRenameSchema(ast))
+  throw new Error(errors_.getASTUnsupportedRenameSchemaErrorMessage(ast))
 }
 
 const formatKeyword = (ast: AST): string => Option.getOrElse(getExpected(ast), () => ast._tag)
 
-const getExpected = (ast: Annotated): Option.Option<string> => {
-  return getIdentifierAnnotation(ast).pipe(
-    Option.orElse(() => getTitleAnnotation(ast)),
+function getBrands(ast: Annotated): string {
+  return Option.match(getBrandAnnotation(ast), {
+    onNone: () => "",
+    onSome: (brands) => brands.map((brand) => ` & Brand<${util_.formatUnknown(brand)}>`).join("")
+  })
+}
+
+const getOrElseExpected = (ast: Annotated): Option.Option<string> =>
+  getTitleAnnotation(ast).pipe(
     Option.orElse(() => getDescriptionAnnotation(ast)),
-    Option.orElse(() => getAutoTitleAnnotation(ast))
+    Option.orElse(() => getAutoTitleAnnotation(ast)),
+    Option.map((s) => s + getBrands(ast))
   )
+
+const getExpected = (ast: Annotated): Option.Option<string> =>
+  Option.orElse(getIdentifierAnnotation(ast), () => getOrElseExpected(ast))
+
+/** @internal */
+export const pruneUndefined = (
+  ast: AST,
+  self: (ast: AST) => AST | undefined,
+  onTransformation: (ast: Transformation) => AST | undefined
+): AST | undefined => {
+  switch (ast._tag) {
+    case "UndefinedKeyword":
+      return neverKeyword
+    case "Union": {
+      const types: Array<AST> = []
+      let hasUndefined = false
+      for (const type of ast.types) {
+        const pruned = self(type)
+        if (pruned) {
+          hasUndefined = true
+          if (!isNeverKeyword(pruned)) {
+            types.push(pruned)
+          }
+        } else {
+          types.push(type)
+        }
+      }
+      if (hasUndefined) {
+        return Union.make(types)
+      }
+      break
+    }
+    case "Suspend":
+      return self(ast.f())
+    case "Transformation":
+      return onTransformation(ast)
+  }
 }

package/src/Stream.ts

@@ -8380,11 +8380,12 @@ export const scheduleWith: {
  *
  * // Creating a single-valued stream from a scoped resource
  * const stream = Stream.scoped(
- *   Effect.acquireUseRelease(
- *     Console.log("acquire"),
- *     () => Console.log("use"),
- *     () => Console.log("release")
- *   )
+ *  Effect.acquireRelease(
+ *    Console.log("acquire"),
+ *    () => Console.log("release")
+ *  )
+ * ).pipe(
+ *  Stream.flatMap(() => Console.log("use"))
  * )
  *
  * // Effect.runPromise(Stream.runCollect(stream)).then(console.log)

package/src/internal/core-effect.ts

@@ -1,5 +1,3 @@
-import type { Exit } from "effect/Exit"
-import { internalCall } from "effect/Utils"
 import * as Arr from "../Array.js"
 import type * as Cause from "../Cause.js"
 import * as Chunk from "../Chunk.js"
@@ -7,6 +5,7 @@ import * as Clock from "../Clock.js"
 import * as Context from "../Context.js"
 import * as Duration from "../Duration.js"
 import type * as Effect from "../Effect.js"
+import type { Exit } from "../Exit.js"
 import type * as Fiber from "../Fiber.js"
 import type * as FiberId from "../FiberId.js"
 import type * as FiberRef from "../FiberRef.js"
@@ -29,6 +28,7 @@ import type * as runtimeFlagsPatch from "../RuntimeFlagsPatch.js"
 import * as Tracer from "../Tracer.js"
 import type { NoInfer } from "../Types.js"
 import type { Unify } from "../Unify.js"
+import { internalCall } from "../Utils.js"
 import * as internalCause from "./cause.js"
 import { clockTag } from "./clock.js"
 import * as core from "./core.js"
@@ -664,23 +664,23 @@ export const filterOrFail: {
 /* @internal */
 export const findFirst: {
   <A, E, R>(
-    f: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
+    predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
   ): (elements: Iterable<A>) => Effect.Effect<Option.Option<A>, E, R>
   <A, E, R>(
     elements: Iterable<A>,
-    f: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
+    predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
   ): Effect.Effect<Option.Option<A>, E, R>
 } = dual(
   2,
   <A, E, R>(
     elements: Iterable<A>,
-    f: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
+    predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
   ): Effect.Effect<Option.Option<A>, E, R> =>
     core.suspend(() => {
       const iterator = elements[Symbol.iterator]()
       const next = iterator.next()
       if (!next.done) {
-        return findLoop(iterator, 0, f, next.value)
+        return findLoop(iterator, 0, predicate, next.value)
       }
       return core.succeed(Option.none())
     })
@@ -762,15 +762,18 @@ export const match: {
 /* @internal */
 export const every: {
   <A, E, R>(
-    f: (a: A, i: number) => Effect.Effect<boolean, E, R>
+    predicate: (a: A, i: number) => Effect.Effect<boolean, E, R>
   ): (elements: Iterable<A>) => Effect.Effect<boolean, E, R>
-  <A, E, R>(elements: Iterable<A>, f: (a: A, i: number) => Effect.Effect<boolean, E, R>): Effect.Effect<boolean, E, R>
+  <A, E, R>(
+    elements: Iterable<A>,
+    predicate: (a: A, i: number) => Effect.Effect<boolean, E, R>
+  ): Effect.Effect<boolean, E, R>
 } = dual(
   2,
   <A, E, R>(
     elements: Iterable<A>,
-    f: (a: A, i: number) => Effect.Effect<boolean, E, R>
-  ): Effect.Effect<boolean, E, R> => core.suspend(() => forAllLoop(elements[Symbol.iterator](), 0, f))
+    predicate: (a: A, i: number) => Effect.Effect<boolean, E, R>
+  ): Effect.Effect<boolean, E, R> => core.suspend(() => forAllLoop(elements[Symbol.iterator](), 0, predicate))
 )
 
 const forAllLoop = <A, E, R>(

package/src/internal/core.ts

@@ -1,4 +1,3 @@
-import { internalCall } from "effect/Utils"
 import * as Arr from "../Array.js"
 import type * as Cause from "../Cause.js"
 import * as Chunk from "../Chunk.js"
@@ -38,7 +37,7 @@ import * as RuntimeFlagsPatch from "../RuntimeFlagsPatch.js"
 import type * as Scope from "../Scope.js"
 import type * as Tracer from "../Tracer.js"
 import type { NoInfer, NotFunction } from "../Types.js"
-import { YieldWrap } from "../Utils.js"
+import { internalCall, YieldWrap } from "../Utils.js"
 import * as _blockedRequests from "./blockedRequests.js"
 import * as internalCause from "./cause.js"
 import * as deferred from "./deferred.js"

package/src/internal/doNotation.ts

@@ -1,6 +1,6 @@
-import type { NoInfer } from "effect/Types"
 import { dual } from "../Function.js"
 import type { Kind, TypeLambda } from "../HKT.js"
+import type { NoInfer } from "../Types.js"
 
 type Map<F extends TypeLambda> = {
   <A, B>(f: (a: A) => B): <R, O, E>(self: Kind<F, R, O, E, A>) => Kind<F, R, O, E, B>

package/src/internal/fiberRuntime.ts

@@ -1,4 +1,3 @@
-import { internalCall, yieldWrapGet } from "effect/Utils"
 import * as RA from "../Array.js"
 import * as Boolean from "../Boolean.js"
 import type * as Cause from "../Cause.js"
@@ -45,6 +44,7 @@ import type * as Scope from "../Scope.js"
 import type * as Supervisor from "../Supervisor.js"
 import type * as Tracer from "../Tracer.js"
 import type { Concurrency, NoInfer } from "../Types.js"
+import { internalCall, yieldWrapGet } from "../Utils.js"
 import * as _RequestBlock from "./blockedRequests.js"
 import * as internalCause from "./cause.js"
 import * as clock from "./clock.js"
@@ -1705,30 +1705,30 @@ const _existsParFound = Symbol.for("effect/Effect/existsPar/found")
 
 /* @internal */
 export const exists: {
-  <A, E, R>(f: (a: A, i: number) => Effect.Effect<boolean, E, R>, options?: {
+  <A, E, R>(predicate: (a: A, i: number) => Effect.Effect<boolean, E, R>, options?: {
     readonly concurrency?: Concurrency | undefined
     readonly batching?: boolean | "inherit" | undefined
     readonly concurrentFinalizers?: boolean | undefined
   }): (elements: Iterable<A>) => Effect.Effect<boolean, E, R>
-  <A, E, R>(elements: Iterable<A>, f: (a: A, i: number) => Effect.Effect<boolean, E, R>, options?: {
+  <A, E, R>(elements: Iterable<A>, predicate: (a: A, i: number) => Effect.Effect<boolean, E, R>, options?: {
     readonly concurrency?: Concurrency | undefined
     readonly batching?: boolean | "inherit" | undefined
     readonly concurrentFinalizers?: boolean | undefined
   }): Effect.Effect<boolean, E, R>
 } = dual(
   (args) => Predicate.isIterable(args[0]) && !core.isEffect(args[0]),
-  <A, E, R>(elements: Iterable<A>, f: (a: A, i: number) => Effect.Effect<boolean, E, R>, options?: {
+  <A, E, R>(elements: Iterable<A>, predicate: (a: A, i: number) => Effect.Effect<boolean, E, R>, options?: {
     readonly concurrency?: Concurrency | undefined
     readonly batching?: boolean | "inherit" | undefined
   }) =>
     concurrency.matchSimple(
       options?.concurrency,
-      () => core.suspend(() => existsLoop(elements[Symbol.iterator](), 0, f)),
+      () => core.suspend(() => existsLoop(elements[Symbol.iterator](), 0, predicate)),
       () =>
         core.matchEffect(
           forEach(
             elements,
-            (a, i) => core.if_(f(a, i), { onTrue: () => core.fail(_existsParFound), onFalse: () => core.void }),
+            (a, i) => core.if_(predicate(a, i), { onTrue: () => core.fail(_existsParFound), onFalse: () => core.void }),
             options
           ),
           {
@@ -1757,7 +1757,7 @@ const existsLoop = <A, E, R>(
 /* @internal */
 export const filter = dual<
   <A, E, R>(
-    f: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>,
+    predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>,
     options?: {
       readonly concurrency?: Concurrency | undefined
       readonly batching?: boolean | "inherit" | undefined
@@ -1765,7 +1765,7 @@ export const filter = dual<
       readonly concurrentFinalizers?: boolean | undefined
     }
   ) => (elements: Iterable<A>) => Effect.Effect<Array<A>, E, R>,
-  <A, E, R>(elements: Iterable<A>, f: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>, options?: {
+  <A, E, R>(elements: Iterable<A>, predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>, options?: {
     readonly concurrency?: Concurrency | undefined
     readonly batching?: boolean | "inherit" | undefined
     readonly negate?: boolean | undefined
@@ -1773,13 +1773,13 @@ export const filter = dual<
   }) => Effect.Effect<Array<A>, E, R>
 >(
   (args) => Predicate.isIterable(args[0]) && !core.isEffect(args[0]),
-  <A, E, R>(elements: Iterable<A>, f: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>, options?: {
+  <A, E, R>(elements: Iterable<A>, predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>, options?: {
     readonly concurrency?: Concurrency | undefined
     readonly batching?: boolean | "inherit" | undefined
     readonly negate?: boolean | undefined
     readonly concurrentFinalizers?: boolean | undefined
   }) => {
-    const predicate = options?.negate ? (a: A, i: number) => core.map(f(a, i), Boolean.not) : f
+    const predicate_ = options?.negate ? (a: A, i: number) => core.map(predicate(a, i), Boolean.not) : predicate
     return concurrency.matchSimple(
       options?.concurrency,
       () =>
@@ -1788,7 +1788,7 @@ export const filter = dual<
             (effect, a, i) =>
               core.zipWith(
                 effect,
-                core.suspend(() => predicate(a, i)),
+                core.suspend(() => predicate_(a, i)),
                 (list, b) => b ? [a, ...list] : list
               ),
             core.sync(() => new Array<A>()) as Effect.Effect<Array<A>, E, R>
@@ -1798,7 +1798,7 @@ export const filter = dual<
         core.map(
           forEach(
             elements,
-            (a, i) => core.map(predicate(a, i), (b) => (b ? Option.some(a) : Option.none())),
+            (a, i) => core.map(predicate_(a, i), (b) => (b ? Option.some(a) : Option.none())),
             options
           ),
           RA.getSomes
@@ -2706,7 +2706,7 @@ const raceAllArbiter = <E, E1, A, A1>(
 export const reduceEffect = dual<
   <Z, E, R, Eff extends Effect.Effect<any, any, any>>(
     zero: Effect.Effect<Z, E, R>,
-    f: (acc: NoInfer<Z>, a: Effect.Effect.Success<Eff>, i: number) => Z,
+    f: (z: NoInfer<Z>, a: Effect.Effect.Success<Eff>, i: number) => Z,
     options?: {
       readonly concurrency?: Concurrency | undefined
       readonly batching?: boolean | "inherit" | undefined
@@ -2716,7 +2716,7 @@ export const reduceEffect = dual<
   <Eff extends Effect.Effect<any, any, any>, Z, E, R>(
     elements: Iterable<Eff>,
     zero: Effect.Effect<Z, E, R>,
-    f: (acc: NoInfer<Z>, a: Effect.Effect.Success<Eff>, i: number) => Z,
+    f: (z: NoInfer<Z>, a: Effect.Effect.Success<Eff>, i: number) => Z,
     options?: {
       readonly concurrency?: Concurrency | undefined
       readonly batching?: boolean | "inherit" | undefined
@@ -2726,7 +2726,7 @@ export const reduceEffect = dual<
 >((args) => Predicate.isIterable(args[0]) && !core.isEffect(args[0]), <A, E, R, Z>(
   elements: Iterable<Effect.Effect<A, E, R>>,
   zero: Effect.Effect<Z, E, R>,
-  f: (acc: NoInfer<Z>, a: NoInfer<A>, i: number) => Z,
+  f: (z: NoInfer<Z>, a: NoInfer<A>, i: number) => Z,
   options?: {
     readonly concurrency?: Concurrency | undefined
     readonly batching?: boolean | "inherit" | undefined

package/src/internal/mailbox.ts

@@ -1,4 +1,3 @@
-import type { Scope } from "effect/Scope"
 import * as Arr from "../Array.js"
 import type { Cause } from "../Cause.js"
 import { NoSuchElementException } from "../Cause.js"
@@ -15,6 +14,7 @@ import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
 import { hasProperty } from "../Predicate.js"
 import type { Scheduler } from "../Scheduler.js"
+import type { Scope } from "../Scope.js"
 import type { Stream } from "../Stream.js"
 import * as channel from "./channel.js"
 import * as channelExecutor from "./channel/channelExecutor.js"

package/src/internal/pool.ts

@@ -1,4 +1,4 @@
-import type { Cause } from "effect/Cause"
+import type { Cause } from "../Cause.js"
 import * as Context from "../Context.js"
 import * as Duration from "../Duration.js"
 import type { Effect, Semaphore } from "../Effect.js"

package/src/internal/redacted.ts

@@ -1,8 +1,8 @@
-import { NodeInspectSymbol } from "effect/Inspectable"
 import * as Equal from "../Equal.js"
 import { pipe } from "../Function.js"
 import { globalValue } from "../GlobalValue.js"
 import * as Hash from "../Hash.js"
+import { NodeInspectSymbol } from "../Inspectable.js"
 import { pipeArguments } from "../Pipeable.js"
 import { hasProperty } from "../Predicate.js"
 import type * as Redacted from "../Redacted.js"

package/src/internal/runtime.ts

@@ -1,8 +1,8 @@
-import { equals } from "effect/Equal"
 import type * as ReadonlyArray from "../Array.js"
 import type * as Cause from "../Cause.js"
 import * as Context from "../Context.js"
 import type * as Effect from "../Effect.js"
+import { equals } from "../Equal.js"
 import * as Exit from "../Exit.js"
 import * as Fiber from "../Fiber.js"
 import * as FiberId from "../FiberId.js"

package/src/internal/schema/errors.ts

@@ -1,4 +1,4 @@
-import * as array_ from "effect/Array"
+import * as array_ from "../../Array.js"
 import type * as AST from "../../SchemaAST.js"
 import * as util_ from "./util.js"
 
@@ -150,14 +150,15 @@ export const getSchemaUnsupportedLiteralSpanErrorMessage = (ast: AST.AST) =>
 // ---------------------------------------------
 
 /** @internal */
-export const getASTUnsupportedSchema = (ast: AST.AST) => getUnsupportedSchemaErrorMessage(undefined, undefined, ast)
+export const getASTUnsupportedSchemaErrorMessage = (ast: AST.AST) =>
+  getUnsupportedSchemaErrorMessage(undefined, undefined, ast)
 
 /** @internal */
-export const getASTUnsupportedKeySchema = (ast: AST.AST) =>
+export const getASTUnsupportedKeySchemaErrorMessage = (ast: AST.AST) =>
   getErrorMessage("Unsupported key schema", undefined, undefined, ast)
 
 /** @internal */
-export const getASTUnsupportedLiteral = (literal: AST.LiteralValue) =>
+export const getASTUnsupportedLiteralErrorMessage = (literal: AST.LiteralValue) =>
   getErrorMessage("Unsupported literal", `literal value: ${util_.formatUnknown(literal)}`)
 
 /** @internal */
@@ -181,7 +182,7 @@ export const getASTDuplicatePropertySignatureTransformationErrorMessage = (key:
   getErrorMessage("Duplicate property signature transformation", `Duplicate key ${util_.formatUnknown(key)}`)
 
 /** @internal */
-export const getASTUnsupportedRenameSchema = (ast: AST.AST): string =>
+export const getASTUnsupportedRenameSchemaErrorMessage = (ast: AST.AST): string =>
   getUnsupportedSchemaErrorMessage(undefined, undefined, ast)
 
 /** @internal */

package/src/internal/schema/util.ts

@@ -1,6 +1,6 @@
-import * as array_ from "effect/Array"
-import * as Predicate from "effect/Predicate"
+import * as array_ from "../../Array.js"
 import type * as ParseResult from "../../ParseResult.js"
+import * as Predicate from "../../Predicate.js"
 import type * as AST from "../../SchemaAST.js"
 
 /** @internal */

package/src/internal/stm/core.ts

@@ -1,4 +1,3 @@
-import { internalCall } from "effect/Utils"
 import * as Cause from "../../Cause.js"
 import * as Context from "../../Context.js"
 import * as Effect from "../../Effect.js"
@@ -15,7 +14,7 @@ import { pipeArguments } from "../../Pipeable.js"
 import { hasProperty } from "../../Predicate.js"
 import type * as Scheduler from "../../Scheduler.js"
 import type * as STM from "../../STM.js"
-import { YieldWrap } from "../../Utils.js"
+import { internalCall, YieldWrap } from "../../Utils.js"
 import { ChannelTypeId } from "../core-stream.js"
 import { withFiberRuntime } from "../core.js"
 import { effectVariance, StreamTypeId } from "../effectable.js"