effect 3.11.2 → 3.11.4

package/src/Micro.ts

@@ -4981,13 +4981,14 @@ export const whileLoop: <A, E, R>(options: {
 })
 
 /**
- * For each element of the provided iterable, run the effect and collect the results.
+ * For each element of the provided iterable, run the effect and collect the
+ * results.
  *
  * If the `discard` option is set to `true`, the results will be discarded and
  * the effect will return `void`.
  *
- * The `concurrency` option can be set to control how many effects are run in
- * parallel. By default, the effects are run sequentially.
+ * The `concurrency` option can be set to control how many effects are run
+ * concurrently. By default, the effects are run sequentially.
  *
  * @since 3.4.0
  * @experimental
@@ -4995,13 +4996,14 @@ export const whileLoop: <A, E, R>(options: {
  */
 export const forEach: {
   /**
-   * For each element of the provided iterable, run the effect and collect the results.
+   * For each element of the provided iterable, run the effect and collect the
+   * results.
    *
    * If the `discard` option is set to `true`, the results will be discarded and
    * the effect will return `void`.
    *
-   * The `concurrency` option can be set to control how many effects are run in
-   * parallel. By default, the effects are run sequentially.
+   * The `concurrency` option can be set to control how many effects are run
+   * concurrently. By default, the effects are run sequentially.
    *
    * @since 3.4.0
    * @experimental
@@ -5016,13 +5018,14 @@ export const forEach: {
     }
   ): Micro<Array<B>, E, R>
   /**
-   * For each element of the provided iterable, run the effect and collect the results.
+   * For each element of the provided iterable, run the effect and collect the
+   * results.
    *
    * If the `discard` option is set to `true`, the results will be discarded and
    * the effect will return `void`.
    *
-   * The `concurrency` option can be set to control how many effects are run in
-   * parallel. By default, the effects are run sequentially.
+   * The `concurrency` option can be set to control how many effects are run
+   * concurrently. By default, the effects are run sequentially.
    *
    * @since 3.4.0
    * @experimental
@@ -5133,7 +5136,8 @@ export const forEach: {
 /**
  * Effectfully filter the elements of the provided iterable.
  *
- * Use the `concurrency` option to control how many elements are processed in parallel.
+ * Use the `concurrency` option to control how many elements are processed
+ * concurrently.
  *
  * @since 3.4.0
  * @experimental
@@ -5152,7 +5156,8 @@ export const filter = <A, E, R>(iterable: Iterable<A>, f: (a: NoInfer<A>) => Mic
 /**
  * Effectfully filter the elements of the provided iterable.
  *
- * Use the `concurrency` option to control how many elements are processed in parallel.
+ * Use the `concurrency` option to control how many elements are processed
+ * concurrently.
  *
  * @since 3.4.0
  * @experimental

package/src/Schema.ts

@@ -689,9 +689,16 @@ const makeEnumsClass = <A extends EnumsDefinition>(
  */
 export const Enums = <A extends EnumsDefinition>(enums: A): Enums<A> => makeEnumsClass(enums)
 
-type Join<Params> = Params extends [infer Head, ...infer Tail] ?
-  `${(Head extends Schema<infer A> ? A : Head) & (AST.LiteralValue)}${Join<Tail>}`
-  : ""
+type AppendType<
+  Template extends string,
+  Next
+> = Next extends AST.LiteralValue ? `${Template}${Next}`
+  : Next extends Schema<infer A extends AST.LiteralValue, infer _I, infer _R> ? `${Template}${A}`
+  : never
+
+type GetTemplateLiteralType<Params> = Params extends [...infer Init, infer Last] ?
+  AppendType<GetTemplateLiteralType<Init>, Last>
+  : ``
 
 /**
  * @category API interface
@@ -707,77 +714,69 @@ type TemplateLiteralParameter = Schema.AnyNoContext | AST.LiteralValue
  */
 export const TemplateLiteral = <Params extends array_.NonEmptyReadonlyArray<TemplateLiteralParameter>>(
   ...[head, ...tail]: Params
-): TemplateLiteral<Join<Params>> => {
-  let astOrs: ReadonlyArray<AST.TemplateLiteral | string> = getTemplateLiterals(
-    getTemplateLiteralParameterAST(head)
-  )
-  for (const span of tail) {
-    astOrs = array_.flatMap(
-      astOrs,
-      (a) => getTemplateLiterals(getTemplateLiteralParameterAST(span)).map((b) => combineTemplateLiterals(a, b))
-    )
+): TemplateLiteral<GetTemplateLiteralType<Params>> => {
+  const spans: Array<AST.TemplateLiteralSpan> = []
+  let h = ""
+  let ts = tail
+
+  if (isSchema(head)) {
+    if (AST.isLiteral(head.ast)) {
+      h = String(head.ast.literal)
+    } else {
+      ts = [head, ...ts]
+    }
+  } else {
+    h = String(head)
   }
-  return make(AST.Union.make(astOrs.map((astOr) => Predicate.isString(astOr) ? new AST.Literal(astOr) : astOr)))
-}
 
-const getTemplateLiteralParameterAST = (span: TemplateLiteralParameter): AST.AST =>
-  isSchema(span) ? span.ast : new AST.Literal(String(span))
-
-const combineTemplateLiterals = (
-  a: AST.TemplateLiteral | string,
-  b: AST.TemplateLiteral | string
-): AST.TemplateLiteral | string => {
-  if (Predicate.isString(a)) {
-    return Predicate.isString(b) ?
-      a + b :
-      new AST.TemplateLiteral(a + b.head, b.spans)
-  }
-  if (Predicate.isString(b)) {
-    return new AST.TemplateLiteral(
-      a.head,
-      array_.modifyNonEmptyLast(
-        a.spans,
-        (span) => new AST.TemplateLiteralSpan(span.type, span.literal + b)
-      )
-    )
+  for (let i = 0; i < ts.length; i++) {
+    const item = ts[i]
+    if (isSchema(item)) {
+      if (i < ts.length - 1) {
+        const next = ts[i + 1]
+        if (isSchema(next)) {
+          if (AST.isLiteral(next.ast)) {
+            spans.push(new AST.TemplateLiteralSpan(item.ast, String(next.ast.literal)))
+            i++
+            continue
+          }
+        } else {
+          spans.push(new AST.TemplateLiteralSpan(item.ast, String(next)))
+          i++
+          continue
+        }
+      }
+      spans.push(new AST.TemplateLiteralSpan(item.ast, ""))
+    } else {
+      spans.push(new AST.TemplateLiteralSpan(new AST.Literal(item), ""))
+    }
   }
-  return new AST.TemplateLiteral(
-    a.head,
-    array_.appendAll(
-      array_.modifyNonEmptyLast(
-        a.spans,
-        (span) => new AST.TemplateLiteralSpan(span.type, span.literal + String(b.head))
-      ),
-      b.spans
-    )
-  )
-}
 
-const getTemplateLiterals = (
-  ast: AST.AST
-): ReadonlyArray<AST.TemplateLiteral | string> => {
-  switch (ast._tag) {
-    case "Literal":
-      return [String(ast.literal)]
-    case "NumberKeyword":
-    case "StringKeyword":
-      return [new AST.TemplateLiteral("", [new AST.TemplateLiteralSpan(ast, "")])]
-    case "Union":
-      return array_.flatMap(ast.types, getTemplateLiterals)
+  if (array_.isNonEmptyArray(spans)) {
+    return make(new AST.TemplateLiteral(h, spans))
+  } else {
+    return make(new AST.TemplateLiteral("", [new AST.TemplateLiteralSpan(new AST.Literal(h), "")]))
   }
-  throw new Error(errors_.getSchemaUnsupportedLiteralSpanErrorMessage(ast))
 }
 
 type TemplateLiteralParserParameters = Schema.Any | AST.LiteralValue
 
-type TemplateLiteralParserParametersType<T> = T extends [infer Head, ...infer Tail] ?
-  readonly [Head extends Schema<infer A, infer _I, infer _R> ? A : Head, ...TemplateLiteralParserParametersType<Tail>]
+type GetTemplateLiteralParserType<Params> = Params extends [infer Head, ...infer Tail] ? readonly [
+    Head extends Schema<infer A, infer _I, infer _R> ? A : Head,
+    ...GetTemplateLiteralParserType<Tail>
+  ]
   : []
 
-type TemplateLiteralParserParametersEncoded<T> = T extends [infer Head, ...infer Tail] ? `${
-    & (Head extends Schema<infer _A, infer I, infer _R> ? I : Head)
-    & (AST.LiteralValue)}${TemplateLiteralParserParametersEncoded<Tail>}`
-  : ""
+type AppendEncoded<
+  Template extends string,
+  Next
+> = Next extends AST.LiteralValue ? `${Template}${Next}`
+  : Next extends Schema<infer _A, infer I extends AST.LiteralValue, infer _R> ? `${Template}${I}`
+  : never
+
+type GetTemplateLiteralParserEncoded<Params> = Params extends [...infer Init, infer Last] ?
+  AppendEncoded<GetTemplateLiteralParserEncoded<Init>, Last>
+  : ``
 
 /**
  * @category API interface
@@ -786,14 +785,20 @@ type TemplateLiteralParserParametersEncoded<T> = T extends [infer Head, ...infer
 export interface TemplateLiteralParser<Params extends array_.NonEmptyReadonlyArray<TemplateLiteralParserParameters>>
   extends
     Schema<
-      TemplateLiteralParserParametersType<Params>,
-      TemplateLiteralParserParametersEncoded<Params>,
+      GetTemplateLiteralParserType<Params>,
+      GetTemplateLiteralParserEncoded<Params>,
       Schema.Context<Params[number]>
     >
 {
   readonly params: Params
 }
 
+const literalValueCoercions: Record<string, ((v: AST.LiteralValue) => AST.LiteralValue)> = {
+  bigint: (v: AST.LiteralValue) => Predicate.isString(v) ? BigInt(v) : v,
+  boolean: (v: AST.LiteralValue) => v === "true" ? true : v === "false" ? false : v,
+  null: (v: AST.LiteralValue) => v === "null" ? null : v
+}
+
 /**
  * @category template literal
  * @since 3.10.0
@@ -803,35 +808,50 @@ export const TemplateLiteralParser = <Params extends array_.NonEmptyReadonlyArra
 ): TemplateLiteralParser<Params> => {
   const encodedSchemas: Array<Schema.Any> = []
   const typeSchemas: Array<Schema.Any> = []
-  const numbers: Array<number> = []
+  const coercions: Record<number, ((v: AST.LiteralValue) => AST.LiteralValue) | undefined> = {}
   for (let i = 0; i < params.length; i++) {
-    const p = params[i]
-    if (isSchema(p)) {
-      const encoded = encodedSchema(p)
+    const param = params[i]
+    if (isSchema(param)) {
+      const encoded = encodedSchema(param)
       if (AST.isNumberKeyword(encoded.ast)) {
-        numbers.push(i)
+        coercions[i] = Number
       }
       encodedSchemas.push(encoded)
-      typeSchemas.push(p)
+      typeSchemas.push(param)
     } else {
-      const literal = Literal(p)
-      encodedSchemas.push(literal)
-      typeSchemas.push(literal)
+      const schema = Literal(param)
+      if (Predicate.isNumber(param)) {
+        coercions[i] = Number
+      } else if (Predicate.isBigInt(param)) {
+        coercions[i] = literalValueCoercions.bigint
+      } else if (Predicate.isBoolean(param)) {
+        coercions[i] = literalValueCoercions.boolean
+      } else if (Predicate.isNull(param)) {
+        coercions[i] = literalValueCoercions.null
+      }
+      encodedSchemas.push(schema)
+      typeSchemas.push(schema)
     }
   }
   const from = TemplateLiteral(...encodedSchemas as any)
   const re = AST.getTemplateLiteralCapturingRegExp(from.ast as AST.TemplateLiteral)
-  return class TemplateLiteralParserClass extends transform(from, Tuple(...typeSchemas), {
+  return class TemplateLiteralParserClass extends transformOrFail(from, Tuple(...typeSchemas), {
     strict: false,
-    decode: (s) => {
-      const out: Array<number | string> = re.exec(s)!.slice(1, params.length + 1)
-      for (let i = 0; i < numbers.length; i++) {
-        const index = numbers[i]
-        out[index] = Number(out[index])
+    decode: (s, _, ast) => {
+      const match = re.exec(s)
+      if (match) {
+        const out: Array<AST.LiteralValue> = match.slice(1, params.length + 1)
+        for (let i = 0; i < out.length; i++) {
+          const coerce = coercions[i]
+          if (coerce) {
+            out[i] = coerce(out[i])
+          }
+        }
+        return ParseResult.succeed(out)
       }
-      return out
+      return ParseResult.fail(new ParseResult.Type(ast, s, `${re.source}: no match for ${JSON.stringify(s)}`))
     },
-    encode: (tuple) => tuple.join("")
+    encode: (tuple) => ParseResult.succeed(tuple.join(""))
   }) {
     static params = params.slice()
   } as any
@@ -2617,6 +2637,8 @@ export interface TypeLiteral<
   ): Simplify<TypeLiteral.Type<Fields, Records>>
 }
 
+const preserveMissingMessageAnnotation = AST.whiteListAnnotations([AST.MissingMessageAnnotationId])
+
 const getDefaultTypeLiteralAST = <
   Fields extends Struct.Fields,
   const Records extends IndexSignature.Records
@@ -2637,7 +2659,7 @@ const getDefaultTypeLiteralAST = <
             const type = ast.type
             const isOptional = ast.isOptional
             const toAnnotations = ast.annotations
-            from.push(new AST.PropertySignature(key, type, isOptional, true))
+            from.push(new AST.PropertySignature(key, type, isOptional, true, preserveMissingMessageAnnotation(ast)))
             to.push(new AST.PropertySignature(key, AST.typeAST(type), isOptional, true, toAnnotations))
             pss.push(
               new AST.PropertySignature(key, type, isOptional, true, toAnnotations)

package/src/SchemaAST.ts

@@ -1096,18 +1096,69 @@ export class Enums implements Annotated {
  */
 export const isEnums: (ast: AST) => ast is Enums = createASTGuard("Enums")
 
+type TemplateLiteralSpanBaseType = StringKeyword | NumberKeyword | Literal
+
+type TemplateLiteralSpanType = TemplateLiteralSpanBaseType | Union<TemplateLiteralSpanType>
+
+const isTemplateLiteralSpanType = (ast: AST): ast is TemplateLiteralSpanType => {
+  switch (ast._tag) {
+    case "Literal":
+    case "NumberKeyword":
+    case "StringKeyword":
+      return true
+    case "Union":
+      return ast.types.every(isTemplateLiteralSpanType)
+  }
+  return false
+}
+
+const templateLiteralSpanUnionTypeToString = (type: TemplateLiteralSpanType): string => {
+  switch (type._tag) {
+    case "Literal":
+      return JSON.stringify(String(type.literal))
+    case "StringKeyword":
+      return "string"
+    case "NumberKeyword":
+      return "number"
+    case "Union":
+      return type.types.map(templateLiteralSpanUnionTypeToString).join(" | ")
+  }
+}
+
+const templateLiteralSpanTypeToString = (type: TemplateLiteralSpanType): string => {
+  switch (type._tag) {
+    case "Literal":
+      return String(type.literal)
+    case "StringKeyword":
+      return "${string}"
+    case "NumberKeyword":
+      return "${number}"
+    case "Union":
+      return "${" + type.types.map(templateLiteralSpanUnionTypeToString).join(" | ") + "}"
+  }
+}
+
 /**
  * @category model
  * @since 3.10.0
  */
 export class TemplateLiteralSpan {
-  constructor(readonly type: StringKeyword | NumberKeyword, readonly literal: string) {}
+  /**
+   * @since 3.10.0
+   */
+  readonly type: TemplateLiteralSpanType
+  constructor(type: AST, readonly literal: string) {
+    if (isTemplateLiteralSpanType(type)) {
+      this.type = type
+    } else {
+      throw new Error(errors_.getSchemaUnsupportedLiteralSpanErrorMessage(type))
+    }
+  }
   /**
    * @since 3.10.0
    */
   toString() {
-    const type = "${" + String(this.type) + "}"
-    return type + this.literal
+    return templateLiteralSpanTypeToString(this.type) + this.literal
   }
   /**
    * @since 3.10.0
@@ -1154,7 +1205,7 @@ export class TemplateLiteral implements Annotated {
 }
 
 const formatTemplateLiteral = (ast: TemplateLiteral): string =>
-  "`" + ast.head + ast.spans.map((span) => String(span)).join("") +
+  "`" + ast.head + ast.spans.map(String).join("") +
   "`"
 
 /**
@@ -1619,7 +1670,7 @@ export const unify = (candidates: ReadonlyArray<AST>): Array<AST> => {
  * @category model
  * @since 3.10.0
  */
-export class Union implements Annotated {
+export class Union<M extends AST = AST> implements Annotated {
   static make = (types: ReadonlyArray<AST>, annotations?: Annotations): AST => {
     return isMembers(types) ? new Union(types, annotations) : types.length === 1 ? types[0] : neverKeyword
   }
@@ -1631,15 +1682,12 @@ export class Union implements Annotated {
    * @since 3.10.0
    */
   readonly _tag = "Union"
-  private constructor(readonly types: Members<AST>, readonly annotations: Annotations = {}) {}
+  private constructor(readonly types: Members<M>, readonly annotations: Annotations = {}) {}
   /**
    * @since 3.10.0
    */
   toString() {
-    return Option.getOrElse(
-      getExpected(this),
-      () => this.types.map(String).join(" | ")
-    )
+    return Option.getOrElse(getExpected(this), () => this.types.map(String).join(" | "))
   }
   /**
    * @since 3.10.0
@@ -2040,25 +2088,53 @@ 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 => {
+  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(getTemplateLiteralPattern).join("|")
+  }
+}
+
 /**
  * @since 3.10.0
  */
 export const getTemplateLiteralRegExp = (ast: TemplateLiteral): RegExp => {
-  let pattern = `^${regexp.escape(ast.head)}`
+  let pattern = `^`
+  if (ast.head !== "") {
+    pattern += regexp.escape(ast.head)
+  }
 
   for (const span of ast.spans) {
-    if (isStringKeyword(span.type)) {
-      pattern += STRING_KEYWORD_PATTERN
-    } else if (isNumberKeyword(span.type)) {
-      pattern += NUMBER_KEYWORD_PATTERN
+    const p = getTemplateLiteralPattern(span.type)
+    pattern += isUnion(span.type) ? `(${p})` : p
+    if (span.literal !== "") {
+      pattern += regexp.escape(span.literal)
     }
-    pattern += regexp.escape(span.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("|")
+  }
+}
+
 /**
  * @since 3.10.0
  */
@@ -2069,11 +2145,7 @@ export const getTemplateLiteralCapturingRegExp = (ast: TemplateLiteral): RegExp
   }
 
   for (const span of ast.spans) {
-    if (isStringKeyword(span.type)) {
-      pattern += `(${STRING_KEYWORD_PATTERN})`
-    } else if (isNumberKeyword(span.type)) {
-      pattern += `(${NUMBER_KEYWORD_PATTERN})`
-    }
+    pattern += `(${getTemplateLiteralCapturingPattern(span.type)})`
     if (span.literal !== "") {
       pattern += `(${regexp.escape(span.literal)})`
     }
@@ -2702,15 +2774,8 @@ export const getParameterBase = (
   }
 }
 
-const equalsTemplateLiteralSpan = Arr.getEquivalence<TemplateLiteralSpan>((self, that) =>
-  self.type._tag === that.type._tag && self.literal === that.literal
-)
-
-const equalsEnums = Arr.getEquivalence<readonly [string, string | number]>((self, that) =>
-  that[0] === self[0] && that[1] === self[1]
-)
-
-const equals = (self: AST, that: AST) => {
+/** @internal  */
+export const equals = (self: AST, that: AST): boolean => {
   switch (self._tag) {
     case "Literal":
       return isLiteral(that) && that.literal === self.literal
@@ -2732,10 +2797,11 @@ const equals = (self: AST, that: AST) => {
       return isTemplateLiteral(that) && that.head === self.head && equalsTemplateLiteralSpan(that.spans, self.spans)
     case "Enums":
       return isEnums(that) && equalsEnums(that.enums, self.enums)
+    case "Union":
+      return isUnion(that) && equalsUnion(self.types, that.types)
     case "Refinement":
     case "TupleType":
     case "TypeLiteral":
-    case "Union":
     case "Suspend":
     case "Transformation":
     case "Declaration":
@@ -2743,6 +2809,16 @@ const equals = (self: AST, that: AST) => {
   }
 }
 
+const equalsTemplateLiteralSpan = Arr.getEquivalence<TemplateLiteralSpan>((self, that): boolean => {
+  return self.literal === that.literal && equals(self.type, that.type)
+})
+
+const equalsEnums = Arr.getEquivalence<readonly [string, string | number]>((self, that) =>
+  that[0] === self[0] && that[1] === self[1]
+)
+
+const equalsUnion = Arr.getEquivalence<AST>(equals)
+
 const intersection = Arr.intersectionWith(equals)
 
 const _keyof = (ast: AST): Array<AST> => {

package/src/internal/core.ts

@@ -528,6 +528,14 @@ export const unsafeAsync = <A, E = never, R = never>(
   return onInterrupt(effect, (_) => isEffect(cancelerRef) ? cancelerRef : void_)
 }
 
+/* @internal */
+export const asyncInterrupt = <A, E = never, R = never>(
+  register: (
+    callback: (_: Effect.Effect<A, E, R>) => void
+  ) => void | Effect.Effect<void, never, R>,
+  blockingOn: FiberId.FiberId = FiberId.none
+): Effect.Effect<A, E, R> => suspend(() => unsafeAsync(register, blockingOn))
+
 /* @internal */
 export const async = <A, E = never, R = never>(
   resume: (

package/src/internal/effect/circular.ts

@@ -47,7 +47,7 @@ class Semaphore {
   }
 
   readonly take = (n: number): Effect.Effect<number> =>
-    core.async<number>((resume) => {
+    core.asyncInterrupt<number>((resume) => {
       if (this.free < n) {
         const observer = () => {
           if (this.free < n) {
@@ -153,7 +153,7 @@ class Latch extends Effectable.Class<void> implements Effect.Latch {
     }
     return this.unsafeSchedule(fiber)
   })
-  await = core.unsafeAsync<void>((resume) => {
+  await = core.asyncInterrupt<void>((resume) => {
     if (this.isOpen) {
       return resume(core.void)
     }

package/src/internal/fiberRuntime.ts

@@ -1132,7 +1132,7 @@ export class FiberRuntime<in out A, in out E = never> extends Effectable.Class<A
           }
         }
       })
-      return core.async<void>((abortResume) => {
+      return core.unsafeAsync<void>((abortResume) => {
         resume = (_: any) => {
           abortResume(core.void)
         }

package/src/internal/mailbox.ts

@@ -299,7 +299,7 @@ class MailboxImpl<A, E> extends Effectable.Class<readonly [messages: Chunk.Chunk
   take: Effect<A, E | NoSuchElementException> = core.suspend(() =>
     this.unsafeTake() ?? core.zipRight(this.awaitTake, this.take)
   )
-  await: Effect<void, E> = core.unsafeAsync<void, E>((resume) => {
+  await: Effect<void, E> = core.asyncInterrupt<void, E>((resume) => {
     if (this.state._tag === "Done") {
       return resume(this.state.exit)
     }
@@ -337,7 +337,7 @@ class MailboxImpl<A, E> extends Effectable.Class<readonly [messages: Chunk.Chunk
   }
 
   private offerRemainingSingle(message: A) {
-    return core.unsafeAsync<boolean>((resume) => {
+    return core.asyncInterrupt<boolean>((resume) => {
       if (this.state._tag !== "Open") {
         return resume(exitFalse)
       }
@@ -351,7 +351,7 @@ class MailboxImpl<A, E> extends Effectable.Class<readonly [messages: Chunk.Chunk
     })
   }
   private offerRemainingArray(remaining: Array<A>) {
-    return core.unsafeAsync<Chunk.Chunk<A>>((resume) => {
+    return core.asyncInterrupt<Chunk.Chunk<A>>((resume) => {
       if (this.state._tag !== "Open") {
         return resume(core.exitSucceed(Chunk.unsafeFromArray(remaining)))
       }
@@ -394,7 +394,7 @@ class MailboxImpl<A, E> extends Effectable.Class<readonly [messages: Chunk.Chunk
     }
     return false
   }
-  private awaitTake = core.unsafeAsync<void, E>((resume) => {
+  private awaitTake = core.asyncInterrupt<void, E>((resume) => {
     if (this.state._tag === "Done") {
       return resume(this.state.exit)
     }

package/src/internal/version.ts

@@ -1,4 +1,4 @@
-let moduleVersion = "3.11.2"
+let moduleVersion = "3.11.4"
 
 export const getCurrentVersion = () => moduleVersion