effect 3.13.11 → 3.14.0

package/src/Runtime.ts

@@ -81,9 +81,28 @@ export interface RunForkOptions {
  * @since 2.0.0
  * @category execution
  */
-export const runFork: <R>(
-  runtime: Runtime<R>
-) => <A, E>(self: Effect.Effect<A, E, R>, options?: RunForkOptions) => Fiber.RuntimeFiber<A, E> = internal.unsafeFork
+export const runFork: {
+  /**
+   * Executes the effect using the provided Scheduler or using the global
+   * Scheduler if not provided
+   *
+   * @since 2.0.0
+   * @category execution
+   */
+  <R>(runtime: Runtime<R>): <A, E>(effect: Effect.Effect<A, E, R>, options?: RunForkOptions | undefined) => Fiber.RuntimeFiber<A, E>
+  /**
+   * Executes the effect using the provided Scheduler or using the global
+   * Scheduler if not provided
+   *
+   * @since 2.0.0
+   * @category execution
+   */
+  <R, A, E>(
+   runtime: Runtime<R>,
+   effect: Effect.Effect<A, E, R>,
+   options?: RunForkOptions | undefined
+  ): Fiber.RuntimeFiber<A, E>
+} = internal.unsafeFork
 
 /**
  * Executes the effect synchronously returning the exit.
@@ -94,8 +113,28 @@ export const runFork: <R>(
  * @since 2.0.0
  * @category execution
  */
-export const runSyncExit: <R>(runtime: Runtime<R>) => <A, E>(effect: Effect.Effect<A, E, R>) => Exit.Exit<A, E> =
-  internal.unsafeRunSyncExit
+export const runSyncExit: {
+  /**
+   * Executes the effect synchronously returning the exit.
+   *
+   * This method is effectful and should only be invoked at the edges of your
+   * program.
+   *
+   * @since 2.0.0
+   * @category execution
+   */
+  <A, E, R>(runtime: Runtime<R>, effect: Effect.Effect<A, E, R>): Exit.Exit<A, E>
+  /**
+   * Executes the effect synchronously returning the exit.
+   *
+   * This method is effectful and should only be invoked at the edges of your
+   * program.
+   *
+   * @since 2.0.0
+   * @category execution
+   */
+  <R>(runtime: Runtime<R>): <A, E>(effect: Effect.Effect<A, E, R>) => Exit.Exit<A, E>
+} = internal.unsafeRunSyncExit
 
 /**
  * Executes the effect synchronously throwing in case of errors or async boundaries.
@@ -106,7 +145,28 @@ export const runSyncExit: <R>(runtime: Runtime<R>) => <A, E>(effect: Effect.Effe
  * @since 2.0.0
  * @category execution
  */
-export const runSync: <R>(runtime: Runtime<R>) => <A, E>(effect: Effect.Effect<A, E, R>) => A = internal.unsafeRunSync
+export const runSync: {
+  /**
+   * Executes the effect synchronously throwing in case of errors or async boundaries.
+   *
+   * This method is effectful and should only be invoked at the edges of your
+   * program.
+   *
+   * @since 2.0.0
+   * @category execution
+   */
+  <A, E, R>(runtime: Runtime<R>, effect: Effect.Effect<A, E, R>): A
+  /**
+   * Executes the effect synchronously throwing in case of errors or async boundaries.
+   *
+   * This method is effectful and should only be invoked at the edges of your
+   * program.
+   *
+   * @since 2.0.0
+   * @category execution
+   */
+  <R>(runtime: Runtime<R>): <A, E>(effect: Effect.Effect<A, E, R>) => A
+} = internal.unsafeRunSync
 
 /**
  * @since 2.0.0
@@ -126,10 +186,37 @@ export interface RunCallbackOptions<in A, in E = never> extends RunForkOptions {
  * @since 2.0.0
  * @category execution
  */
-export const runCallback: <R>(
-  runtime: Runtime<R>
-) => <A, E>(effect: Effect.Effect<A, E, R>, options?: RunCallbackOptions<A, E> | undefined) => Cancel<A, E> =
-  internal.unsafeRunCallback
+export const runCallback: {
+  /**
+   * Executes the effect asynchronously, eventually passing the exit value to
+   * the specified callback.
+   *
+   * This method is effectful and should only be invoked at the edges of your
+   * program.
+   *
+   * @since 2.0.0
+   * @category execution
+   */
+  <R>(runtime: Runtime<R>): <A, E>(
+    effect: Effect.Effect<A, E, R>,
+    options?: RunCallbackOptions<A, E> | undefined
+  ) => (fiberId?: FiberId.FiberId, options?: RunCallbackOptions<A, E> | undefined) => void
+  /**
+   * Executes the effect asynchronously, eventually passing the exit value to
+   * the specified callback.
+   *
+   * This method is effectful and should only be invoked at the edges of your
+   * program.
+   *
+   * @since 2.0.0
+   * @category execution
+   */
+  <R, A, E>(
+   runtime: Runtime<R>,
+   effect: Effect.Effect<A, E, R>,
+   options?: RunCallbackOptions<A, E> | undefined
+  ): (fiberId?: FiberId.FiberId, options?: RunCallbackOptions<A, E> | undefined) => void
+} = internal.unsafeRunCallback
 
 /**
  * Runs the `Effect`, returning a JavaScript `Promise` that will be resolved
@@ -142,10 +229,36 @@ export const runCallback: <R>(
  * @since 2.0.0
  * @category execution
  */
-export const runPromise: <R>(
-  runtime: Runtime<R>
-) => <A, E>(effect: Effect.Effect<A, E, R>, options?: { readonly signal?: AbortSignal } | undefined) => Promise<A> =
-  internal.unsafeRunPromise
+export const runPromise: {
+  /**
+   * Runs the `Effect`, returning a JavaScript `Promise` that will be resolved
+   * with the value of the effect once the effect has been executed, or will be
+   * rejected with the first error or exception throw by the effect.
+   *
+   * This method is effectful and should only be used at the edges of your
+   * program.
+   *
+   * @since 2.0.0
+   * @category execution
+   */
+  <R>(runtime: Runtime<R>): <A, E>(effect: Effect.Effect<A, E, R>, options?: { readonly signal?: AbortSignal } | undefined) => Promise<A>
+  /**
+   * Runs the `Effect`, returning a JavaScript `Promise` that will be resolved
+   * with the value of the effect once the effect has been executed, or will be
+   * rejected with the first error or exception throw by the effect.
+   *
+   * This method is effectful and should only be used at the edges of your
+   * program.
+   *
+   * @since 2.0.0
+   * @category execution
+   */
+  <R, A, E>(
+   runtime: Runtime<R>,
+   effect: Effect.Effect<A, E, R>,
+   options?: { readonly signal?: AbortSignal } | undefined
+  ): Promise<A>
+} = internal.unsafeRunPromise
 
 /**
  * Runs the `Effect`, returning a JavaScript `Promise` that will be resolved
@@ -157,12 +270,37 @@ export const runPromise: <R>(
  * @since 2.0.0
  * @category execution
  */
-export const runPromiseExit: <R>(
-  runtime: Runtime<R>
-) => <A, E>(
-  effect: Effect.Effect<A, E, R>,
-  options?: { readonly signal?: AbortSignal } | undefined
-) => Promise<Exit.Exit<A, E>> = internal.unsafeRunPromiseExit
+export const runPromiseExit: {
+  /**
+   * Runs the `Effect`, returning a JavaScript `Promise` that will be resolved
+   * with the `Exit` state of the effect once the effect has been executed.
+   *
+   * This method is effectful and should only be used at the edges of your
+   * program.
+   *
+   * @since 2.0.0
+   * @category execution
+   */
+  <R>(runtime: Runtime<R>): <A, E>(
+    effect: Effect.Effect<A, E, R>,
+    options?: { readonly signal?: AbortSignal } | undefined
+  ) => Promise<Exit.Exit<A, E>>
+  /**
+   * Runs the `Effect`, returning a JavaScript `Promise` that will be resolved
+   * with the `Exit` state of the effect once the effect has been executed.
+   *
+   * This method is effectful and should only be used at the edges of your
+   * program.
+   *
+   * @since 2.0.0
+   * @category execution
+   */
+  <R, A, E>(
+   runtime: Runtime<R>,
+   effect: Effect.Effect<A, E, R>,
+   options?: { readonly signal?: AbortSignal } | undefined
+  ): Promise<Exit.Exit<A, E>>
+} = internal.unsafeRunPromiseExit
 
 /**
  * @since 2.0.0

package/src/Schema.ts

@@ -2831,7 +2831,7 @@ export interface TypeLiteral<
   ): Simplify<TypeLiteral.Type<Fields, Records>>
 }
 
-const preserveMissingMessageAnnotation = AST.whiteListAnnotations([AST.MissingMessageAnnotationId])
+const preserveMissingMessageAnnotation = AST.pickAnnotations([AST.MissingMessageAnnotationId])
 
 const getDefaultTypeLiteralAST = <
   Fields extends Struct.Fields,
@@ -3513,7 +3513,7 @@ const intersectTypeLiterals = (
   throw new Error(errors_.getSchemaExtendErrorMessage(x, y, path))
 }
 
-const preserveRefinementAnnotations = AST.blackListAnnotations([AST.IdentifierAnnotationId])
+const preserveRefinementAnnotations = AST.omitAnnotations([AST.IdentifierAnnotationId])
 
 const addRefinementToMembers = (refinement: AST.Refinement, asts: ReadonlyArray<AST.AST>): Array<AST.Refinement> =>
   asts.map((ast) => new AST.Refinement(ast, refinement.filter, preserveRefinementAnnotations(refinement)))

package/src/SchemaAST.ts

@@ -2082,12 +2082,12 @@ export const isTypeLiteralTransformation: (ast: TransformationKind) => ast is Ty
  *
  * @since 3.10.0
  */
-export const annotations = (ast: AST, a: Annotations): AST => {
+export const annotations = (ast: AST, overrides: Annotations): AST => {
   const d = Object.getOwnPropertyDescriptors(ast)
-  const value = { ...ast.annotations, ...a }
+  const value = { ...ast.annotations, ...overrides }
   const surrogate = getSurrogateAnnotation(ast)
   if (Option.isSome(surrogate)) {
-    value[SurrogateAnnotationId] = annotations(surrogate.value, a)
+    value[SurrogateAnnotationId] = annotations(surrogate.value, overrides)
   }
   d.annotations.value = value
   return Object.create(Object.getPrototypeOf(ast), d)
@@ -2611,6 +2611,40 @@ export const getCompiler = <A>(match: Match<A>): Compiler<A> => {
   return compile
 }
 
+/** @internal */
+export const pickAnnotations =
+  (annotationIds: ReadonlyArray<symbol>) => (annotated: Annotated): Annotations | undefined => {
+    let out: { [_: symbol]: unknown } | undefined = undefined
+    for (const id of annotationIds) {
+      if (Object.prototype.hasOwnProperty.call(annotated.annotations, id)) {
+        if (out === undefined) {
+          out = {}
+        }
+        out[id] = annotated.annotations[id]
+      }
+    }
+    return out
+  }
+
+/** @internal */
+export const omitAnnotations =
+  (annotationIds: ReadonlyArray<symbol>) => (annotated: Annotated): Annotations | undefined => {
+    const out = { ...annotated.annotations }
+    for (const id of annotationIds) {
+      delete out[id]
+    }
+    return out
+  }
+
+const preserveTransformationAnnotations = pickAnnotations([
+  ExamplesAnnotationId,
+  DefaultAnnotationId,
+  JSONSchemaAnnotationId,
+  ArbitraryAnnotationId,
+  PrettyAnnotationId,
+  EquivalenceAnnotationId
+])
+
 /**
  * @since 3.10.0
  */
@@ -2658,37 +2692,18 @@ export const typeAST = (ast: AST): AST => {
         ast :
         new Refinement(from, ast.filter, ast.annotations)
     }
-    case "Transformation":
-      return typeAST(ast.to)
+    case "Transformation": {
+      const preserve = preserveTransformationAnnotations(ast)
+      return typeAST(
+        preserve !== undefined ?
+          annotations(ast.to, preserve) :
+          ast.to
+      )
+    }
   }
   return ast
 }
 
-/** @internal */
-export const whiteListAnnotations =
-  (annotationIds: ReadonlyArray<symbol>) => (annotated: Annotated): Annotations | undefined => {
-    let out: { [_: symbol]: unknown } | undefined = undefined
-    for (const id of annotationIds) {
-      if (Object.prototype.hasOwnProperty.call(annotated.annotations, id)) {
-        if (out === undefined) {
-          out = {}
-        }
-        out[id] = annotated.annotations[id]
-      }
-    }
-    return out
-  }
-
-/** @internal */
-export const blackListAnnotations =
-  (annotationIds: ReadonlyArray<symbol>) => (annotated: Annotated): Annotations | undefined => {
-    const out = { ...annotated.annotations }
-    for (const id of annotationIds) {
-      delete out[id]
-    }
-    return out
-  }
-
 // To generate a JSON Schema from a recursive schema, an `identifier` annotation
 // is required. So, when we calculate the encodedAST, we need to preserve the
 // annotation in the form of an internal custom annotation that acts as a

package/src/TestClock.ts

@@ -4,6 +4,7 @@
 import * as Chunk from "./Chunk.js"
 import type * as Clock from "./Clock.js"
 import * as Context from "./Context.js"
+import * as DateTime from "./DateTime.js"
 import type * as Deferred from "./Deferred.js"
 import * as Duration from "./Duration.js"
 import type * as Effect from "./Effect.js"
@@ -499,13 +500,19 @@ export const save = (): Effect.Effect<Effect.Effect<void>> => testClockWith((tes
 
 /**
  * Accesses a `TestClock` instance in the context and sets the clock time
- * to the specified `Instant`, running any actions scheduled for on or before
+ * to the specified `Instant` or `Date`, running any actions scheduled for on or before
  * the new time in order.
  *
  * @since 2.0.0
  */
-export const setTime = (instant: number): Effect.Effect<void> =>
-  testClockWith((testClock) => testClock.setTime(instant))
+export const setTime = (input: DateTime.DateTime.Input): Effect.Effect<void> =>
+  testClockWith((testClock) =>
+    testClock.setTime(
+      typeof input === "number"
+        ? input
+        : DateTime.unsafeMake(input).epochMillis
+    )
+  )
 
 /**
  * Semantically blocks the current fiber until the clock time is equal to or

package/src/Tracer.ts

@@ -121,6 +121,7 @@ export interface Span {
   end(endTime: bigint, exit: Exit.Exit<unknown, unknown>): void
   attribute(key: string, value: unknown): void
   event(name: string, startTime: bigint, attributes?: Record<string, unknown>): void
+  addLinks(links: ReadonlyArray<SpanLink>): void
 }
 
 /**

package/src/index.ts

@@ -406,6 +406,11 @@ export * as KeyedPool from "./KeyedPool.js"
  */
 export * as Layer from "./Layer.js"
 
+/**
+ * @since 3.14.0
+ */
+export * as LayerMap from "./LayerMap.js"
+
 /**
  * A data type for immutable linked lists representing ordered collections of elements of type `A`.
  *

package/src/internal/channel/channelExecutor.ts

@@ -7,7 +7,9 @@ import * as Effect from "../../Effect.js"
 import * as ExecutionStrategy from "../../ExecutionStrategy.js"
 import * as Exit from "../../Exit.js"
 import * as Fiber from "../../Fiber.js"
+import * as FiberId from "../../FiberId.js"
 import { dual, identity, pipe } from "../../Function.js"
+import * as HashSet from "../../HashSet.js"
 import * as Option from "../../Option.js"
 import * as Scope from "../../Scope.js"
 import type * as UpstreamPullStrategy from "../../UpstreamPullStrategy.js"
@@ -1143,8 +1145,9 @@ export const runIn = dual<
       restore(run(channelDeferred, scopeDeferred, child)).pipe(
         Effect.forkIn(scope),
         Effect.flatMap((fiber) =>
-          scope.addFinalizer(() =>
-            Deferred.isDone(channelDeferred).pipe(
+          scope.addFinalizer((exit) => {
+            const interruptors = Exit.isFailure(exit) ? Cause.interruptors(exit.cause) : undefined
+            return Deferred.isDone(channelDeferred).pipe(
               Effect.flatMap((isDone) =>
                 isDone
                   ? Deferred.succeed(scopeDeferred, void 0).pipe(
@@ -1152,12 +1155,16 @@ export const runIn = dual<
                     Effect.zipRight(Fiber.inheritAll(fiber))
                   )
                   : Deferred.succeed(scopeDeferred, void 0).pipe(
-                    Effect.zipRight(Fiber.interrupt(fiber)),
+                    Effect.zipRight(
+                      interruptors && HashSet.size(interruptors) > 0
+                        ? Fiber.interruptAs(fiber, FiberId.combineAll(interruptors))
+                        : Fiber.interrupt(fiber)
+                    ),
                     Effect.zipRight(Fiber.inheritAll(fiber))
                   )
               )
             )
-          ).pipe(Effect.zipRight(restore(Deferred.await(channelDeferred))))
+          }).pipe(Effect.zipRight(restore(Deferred.await(channelDeferred))))
         )
       )
     ))

package/src/internal/core-effect.ts

@@ -1950,6 +1950,21 @@ export const annotateCurrentSpan: {
   ))
 }
 
+/* @internal */
+export const linkSpanCurrent: {
+  (span: Tracer.AnySpan, attributes?: Readonly<Record<string, unknown>> | undefined): Effect.Effect<void>
+  (links: ReadonlyArray<Tracer.SpanLink>): Effect.Effect<void>
+} = function(): Effect.Effect<void> {
+  const args = arguments
+  const links: ReadonlyArray<Tracer.SpanLink> = Array.isArray(args[0])
+    ? args[0]
+    : [{ _tag: "SpanLink", span: args[0], attributes: args[1] ?? {} }]
+  return ignore(core.flatMap(
+    currentSpan,
+    (span) => core.sync(() => span.addLinks(links))
+  ))
+}
+
 /* @internal */
 export const annotateSpans = dual<
   {

package/src/internal/core.ts

@@ -3147,7 +3147,8 @@ const NoopSpanProto: Omit<Tracer.Span, "parent" | "name" | "context"> = {
   kind: "internal",
   attribute() {},
   event() {},
-  end() {}
+  end() {},
+  addLinks() {}
 }
 
 /** @internal */

package/src/internal/dateTime.ts

@@ -299,6 +299,9 @@ export const makeZonedFromString = (input: string): Option.Option<DateTime.Zoned
 /** @internal */
 export const now: Effect.Effect<DateTime.Utc> = core.map(Clock.currentTimeMillis, makeUtc)
 
+/** @internal */
+export const nowAsDate: Effect.Effect<Date> = core.map(Clock.currentTimeMillis, (millis) => new Date(millis))
+
 /** @internal */
 export const unsafeNow: LazyArg<DateTime.Utc> = () => makeUtc(Date.now())
 

package/src/internal/effect/circular.ts

@@ -146,6 +146,11 @@ class Latch extends Effectable.Class<void> implements Effect.Latch {
     this.isOpen = true
     return this.unsafeSchedule(fiber)
   })
+  unsafeOpen() {
+    if (this.isOpen) return
+    this.isOpen = true
+    this.flushWaiters()
+  }
   release = core.withFiberRuntime<void>((fiber) => {
     if (this.isOpen) {
       return core.void

package/src/internal/hashMap.ts

@@ -555,3 +555,12 @@ export const some: {
     return false
   }
 )
+
+/** @internal */
+export const every: {
+  <K, A>(predicate: (a: NoInfer<A>, k: K) => boolean): (self: HM.HashMap<K, A>) => boolean
+  <K, A>(self: HM.HashMap<K, A>, predicate: (a: A, k: K) => boolean): boolean
+} = Dual.dual(
+  2,
+  <K, A>(self: HM.HashMap<K, A>, predicate: (a: A, k: K) => boolean): boolean => !some(self, (a, k) => !predicate(a, k))
+)

package/src/internal/layer.ts

@@ -67,6 +67,11 @@ export const MemoMapTypeId: Layer.MemoMapTypeId = Symbol.for(
   MemoMapTypeIdKey
 ) as Layer.MemoMapTypeId
 
+/** @internal */
+export const CurrentMemoMap = Context.Reference<Layer.CurrentMemoMap>()("effect/Layer/CurrentMemoMap", {
+  defaultValue: () => unsafeMakeMemoMap()
+})
+
 /** @internal */
 export type Primitive =
   | ExtendScope
@@ -337,7 +342,7 @@ export const buildWithScope = dual<
 >(2, (self, scope) =>
   core.flatMap(
     makeMemoMap,
-    (memoMap) => core.flatMap(makeBuilder(self, scope), (run) => run(memoMap))
+    (memoMap) => buildWithMemoMap(self, memoMap, scope)
   ))
 
 /** @internal */
@@ -351,7 +356,14 @@ export const buildWithMemoMap = dual<
     memoMap: Layer.MemoMap,
     scope: Scope.Scope
   ) => Effect.Effect<Context.Context<ROut>, E, RIn>
->(3, (self, memoMap, scope) => core.flatMap(makeBuilder(self, scope), (run) => run(memoMap)))
+>(
+  3,
+  (self, memoMap, scope) =>
+    core.flatMap(
+      makeBuilder(self, scope),
+      (run) => effect.provideService(run(memoMap), CurrentMemoMap, memoMap)
+    )
+)
 
 const makeBuilder = <RIn, E, ROut>(
   self: Layer.Layer<ROut, E, RIn>,

package/src/internal/rcMap.ts

@@ -154,10 +154,16 @@ const acquire = core.fnUntraced(function*<K, A, E>(self: RcMapImpl<K, A, E>, key
   const scope = yield* fiberRuntime.scopeMake()
   const deferred = yield* core.deferredMake<A, E>()
   const acquire = self.lookup(key)
-  yield* restore(core.fiberRefLocally(
+  const contextMap = new Map(self.context.unsafeMap)
+  yield* restore(core.mapInputContext(
     acquire as Effect<A, E>,
-    core.currentContext,
-    Context.add(self.context, fiberRuntime.scopeTag, scope)
+    (inputContext: Context.Context<never>) => {
+      inputContext.unsafeMap.forEach((value, key) => {
+        contextMap.set(key, value)
+      })
+      contextMap.set(fiberRuntime.scopeTag.key, scope)
+      return Context.unsafeMake(contextMap)
+    }
   )).pipe(
     core.exit,
     core.flatMap((exit) => core.deferredDone(deferred, exit)),
@@ -194,6 +200,10 @@ const release = <K, A, E>(self: RcMapImpl<K, A, E>, key: K, entry: State.Entry<A
       return core.scopeClose(entry.scope, core.exitVoid)
     }
 
+    if (!Duration.isFinite(self.idleTimeToLive)) {
+      return core.void
+    }
+
     entry.expiresAt = clock.unsafeCurrentTimeMillis() + Duration.toMillis(self.idleTimeToLive)
     if (entry.fiber) return core.void