effect 3.11.4 → 3.11.5

package/src/SchemaAST.ts

@@ -2072,9 +2072,14 @@ export const isTypeLiteralTransformation: (ast: TransformationKind) => ast is Ty
  *
  * @since 3.10.0
  */
-export const annotations = (ast: AST, annotations: Annotations): AST => {
+export const annotations = (ast: AST, a: Annotations): AST => {
   const d = Object.getOwnPropertyDescriptors(ast)
-  d.annotations.value = { ...ast.annotations, ...annotations }
+  const value = { ...ast.annotations, ...a }
+  const surrogate = getSurrogateAnnotation(ast)
+  if (Option.isSome(surrogate)) {
+    value[SurrogateAnnotationId] = annotations(surrogate.value, a)
+  }
+  d.annotations.value = value
   return Object.create(Object.getPrototypeOf(ast), d)
 }
 
@@ -2679,6 +2684,22 @@ function changeMap<A>(as: ReadonlyArray<A>, f: (a: A) => A): ReadonlyArray<A> {
   return changed ? out : as
 }
 
+/**
+ * Returns the from part of a transformation if it exists
+ *
+ * @internal
+ */
+export const getTransformationFrom = (ast: AST): AST | undefined => {
+  switch (ast._tag) {
+    case "Transformation":
+      return ast.from
+    case "Refinement":
+      return getTransformationFrom(ast.from)
+    case "Suspend":
+      return getTransformationFrom(ast.f())
+  }
+}
+
 const encodedAST_ = (ast: AST, isBound: boolean): AST => {
   switch (ast._tag) {
     case "Declaration": {
@@ -2730,14 +2751,17 @@ const encodedAST_ = (ast: AST, isBound: boolean): AST => {
         if (from === ast.from) {
           return ast
         }
-        if (!isTransformation(ast.from) && hasStableFilter(ast)) {
-          return new Refinement(from, ast.filter)
+        if (getTransformationFrom(ast.from) === undefined && hasStableFilter(ast)) {
+          return new Refinement(from, ast.filter, ast.annotations)
         }
       }
-      return from
+      const identifier = createJSONIdentifierAnnotation(ast)
+      return identifier ? annotations(from, identifier) : from
+    }
+    case "Transformation": {
+      const identifier = createJSONIdentifierAnnotation(ast)
+      return encodedAST_(identifier ? annotations(ast.from, identifier) : ast.from, isBound)
     }
-    case "Transformation":
-      return encodedAST_(ast.from, isBound)
   }
   return ast
 }

package/src/internal/core.ts

@@ -536,8 +536,7 @@ export const asyncInterrupt = <A, E = never, R = never>(
   blockingOn: FiberId.FiberId = FiberId.none
 ): Effect.Effect<A, E, R> => suspend(() => unsafeAsync(register, blockingOn))
 
-/* @internal */
-export const async = <A, E = never, R = never>(
+const async_ = <A, E = never, R = never>(
   resume: (
     callback: (_: Effect.Effect<A, E, R>) => void,
     signal: AbortSignal
@@ -580,6 +579,10 @@ export const async = <A, E = never, R = never>(
       effect
   })
 }
+export {
+  /** @internal */
+  async_ as async
+}
 
 /* @internal */
 export const catchAllCause = dual<
@@ -820,7 +823,7 @@ export const andThen: {
     if (isEffect(b)) {
       return b
     } else if (isPromiseLike(b)) {
-      return async<any, Cause.UnknownException>((resume) => {
+      return unsafeAsync<any, Cause.UnknownException>((resume) => {
         b.then((a) => resume(succeed(a)), (e) => resume(fail(new UnknownException(e))))
       })
     }
@@ -1304,7 +1307,7 @@ export const tap = dual<
       if (isEffect(b)) {
         return as(b, a)
       } else if (isPromiseLike(b)) {
-        return async<any, Cause.UnknownException>((resume) => {
+        return unsafeAsync<any, Cause.UnknownException>((resume) => {
           b.then((_) => resume(succeed(a)), (e) => resume(fail(new UnknownException(e))))
         })
       }
@@ -1567,7 +1570,7 @@ export const zipWith: {
 ): Effect.Effect<B, E | E2, R | R2> => flatMap(self, (a) => map(that, (b) => f(a, b))))
 
 /* @internal */
-export const never: Effect.Effect<never> = async<never>(() => {
+export const never: Effect.Effect<never> = asyncInterrupt<never>(() => {
   const interval = setInterval(() => {
     //
   }, 2 ** 31 - 1)
@@ -2842,7 +2845,7 @@ export const deferredMakeAs = <A, E = never>(fiberId: FiberId.FiberId): Effect.E
 
 /* @internal */
 export const deferredAwait = <A, E>(self: Deferred.Deferred<A, E>): Effect.Effect<A, E> =>
-  async<A, E>((resume) => {
+  asyncInterrupt<A, E>((resume) => {
     const state = MutableRef.get(self.state)
     switch (state._tag) {
       case DeferredOpCodes.OP_STATE_DONE: {

package/src/internal/version.ts

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