effect 3.13.12 → 3.14.0

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
 

package/src/internal/runtime.ts

@@ -26,9 +26,33 @@ import * as OpCodes from "./opCodes/effect.js"
 import * as runtimeFlags from "./runtimeFlags.js"
 import * as supervisor_ from "./supervisor.js"
 
+const makeDual = <Args extends Array<any>, Return>(
+  f: (runtime: Runtime.Runtime<never>, effect: Effect.Effect<any, any>, ...args: Args) => Return
+): {
+  <R>(runtime: Runtime.Runtime<R>): <A, E>(effect: Effect.Effect<A, E, R>, ...args: Args) => Return
+  <R, A, E>(runtime: Runtime.Runtime<R>, effect: Effect.Effect<A, E, R>, ...args: Args): Return
+} =>
+  function(this: any) {
+    if (arguments.length === 1) {
+      const runtime = arguments[0]
+      return (effect: any, ...args: Args) => f(runtime, effect, ...args)
+    }
+    return f.apply(this, arguments as any)
+  } as any
+
 /** @internal */
-export const unsafeFork = <R>(runtime: Runtime.Runtime<R>) =>
-<A, E>(
+export const unsafeFork: {
+  <R>(runtime: Runtime.Runtime<R>): <A, E>(
+    effect: Effect.Effect<A, E, R>,
+    options?: Runtime.RunForkOptions | undefined
+  ) => Fiber.RuntimeFiber<A, E>
+  <R, A, E>(
+    runtime: Runtime.Runtime<R>,
+    effect: Effect.Effect<A, E, R>,
+    options?: Runtime.RunForkOptions | undefined
+  ): Fiber.RuntimeFiber<A, E>
+} = makeDual(<R, A, E>(
+  runtime: Runtime.Runtime<R>,
   self: Effect.Effect<A, E, R>,
   options?: Runtime.RunForkOptions
 ): Fiber.RuntimeFiber<A, E> => {
@@ -93,15 +117,25 @@ export const unsafeFork = <R>(runtime: Runtime.Runtime<R>) =>
   }
 
   return fiberRuntime
-}
+})
 
 /** @internal */
-export const unsafeRunCallback = <R>(runtime: Runtime.Runtime<R>) =>
-<A, E>(
-  effect: Effect.Effect<A, E, R>,
-  options: Runtime.RunCallbackOptions<A, E> = {}
-): (fiberId?: FiberId.FiberId, options?: Runtime.RunCallbackOptions<A, E> | undefined) => void => {
-  const fiberRuntime = unsafeFork(runtime)(effect, options)
+export const unsafeRunCallback: {
+  <R>(runtime: Runtime.Runtime<R>): <A, E>(
+    effect: Effect.Effect<A, E, R>,
+    options?: Runtime.RunCallbackOptions<A, E> | undefined
+  ) => (fiberId?: FiberId.FiberId, options?: Runtime.RunCallbackOptions<A, E> | undefined) => void
+  <R, A, E>(
+    runtime: Runtime.Runtime<R>,
+    effect: Effect.Effect<A, E, R>,
+    options?: Runtime.RunCallbackOptions<A, E> | undefined
+  ): (fiberId?: FiberId.FiberId, options?: Runtime.RunCallbackOptions<A, E> | undefined) => void
+} = makeDual((
+  runtime,
+  effect,
+  options: Runtime.RunCallbackOptions<any, any> = {}
+): (fiberId?: FiberId.FiberId, options?: Runtime.RunCallbackOptions<any, any> | undefined) => void => {
+  const fiberRuntime = unsafeFork(runtime, effect, options)
 
   if (options.onExit) {
     fiberRuntime.addObserver((exit) => {
@@ -119,17 +153,19 @@ export const unsafeRunCallback = <R>(runtime: Runtime.Runtime<R>) =>
           : undefined
       }
     )
-}
+})
 
 /** @internal */
-export const unsafeRunSync = <R>(runtime: Runtime.Runtime<R>) => <A, E>(effect: Effect.Effect<A, E, R>): A => {
+export const unsafeRunSync: {
+  <A, E, R>(runtime: Runtime.Runtime<R>, effect: Effect.Effect<A, E, R>): A
+  <R>(runtime: Runtime.Runtime<R>): <A, E>(effect: Effect.Effect<A, E, R>) => A
+} = makeDual((runtime, effect) => {
   const result = unsafeRunSyncExit(runtime)(effect)
   if (result._tag === "Failure") {
     throw fiberFailure(result.effect_instruction_i0)
-  } else {
-    return result.effect_instruction_i0
   }
-}
+  return result.effect_instruction_i0
+})
 
 class AsyncFiberExceptionImpl<A, E = never> extends Error implements Runtime.AsyncFiberException<A, E> {
   readonly _tag = "AsyncFiberException"
@@ -229,31 +265,47 @@ const fastPath = <A, E, R>(effect: Effect.Effect<A, E, R>): Exit.Exit<A, E> | un
 }
 
 /** @internal */
-export const unsafeRunSyncExit =
-  <R>(runtime: Runtime.Runtime<R>) => <A, E>(effect: Effect.Effect<A, E, R>): Exit.Exit<A, E> => {
-    const op = fastPath(effect)
-    if (op) {
-      return op
-    }
-    const scheduler = new scheduler_.SyncScheduler()
-    const fiberRuntime = unsafeFork(runtime)(effect, { scheduler })
-    scheduler.flush()
-    const result = fiberRuntime.unsafePoll()
-    if (result) {
-      return result
-    }
-    return core.exitDie(core.capture(asyncFiberException(fiberRuntime), core.currentSpanFromFiber(fiberRuntime)))
+export const unsafeRunSyncExit: {
+  <A, E, R>(runtime: Runtime.Runtime<R>, effect: Effect.Effect<A, E, R>): Exit.Exit<A, E>
+  <R>(runtime: Runtime.Runtime<R>): <A, E>(effect: Effect.Effect<A, E, R>) => Exit.Exit<A, E>
+} = makeDual((runtime, effect) => {
+  const op = fastPath(effect)
+  if (op) {
+    return op
   }
+  const scheduler = new scheduler_.SyncScheduler()
+  const fiberRuntime = unsafeFork(runtime)(effect, { scheduler })
+  scheduler.flush()
+  const result = fiberRuntime.unsafePoll()
+  if (result) {
+    return result
+  }
+  return core.exitDie(core.capture(asyncFiberException(fiberRuntime), core.currentSpanFromFiber(fiberRuntime)))
+})
 
 /** @internal */
-export const unsafeRunPromise = <R>(runtime: Runtime.Runtime<R>) =>
-<A, E>(
-  effect: Effect.Effect<A, E, R>,
+export const unsafeRunPromise: {
+  <R>(runtime: Runtime.Runtime<R>): <A, E>(
+    effect: Effect.Effect<A, E, R>,
+    options?: {
+      readonly signal?: AbortSignal | undefined
+    } | undefined
+  ) => Promise<A>
+  <R, A, E>(
+    runtime: Runtime.Runtime<R>,
+    effect: Effect.Effect<A, E, R>,
+    options?: {
+      readonly signal?: AbortSignal | undefined
+    } | undefined
+  ): Promise<A>
+} = makeDual((
+  runtime,
+  effect,
   options?: {
     readonly signal?: AbortSignal | undefined
   } | undefined
-): Promise<A> =>
-  unsafeRunPromiseExit(runtime)(effect, options).then((result) => {
+) =>
+  unsafeRunPromiseExit(runtime, effect, options).then((result) => {
     switch (result._tag) {
       case OpCodes.OP_SUCCESS: {
         return result.effect_instruction_i0
@@ -263,16 +315,29 @@ export const unsafeRunPromise = <R>(runtime: Runtime.Runtime<R>) =>
       }
     }
   })
+)
 
 /** @internal */
-export const unsafeRunPromiseExit = <R>(runtime: Runtime.Runtime<R>) =>
-<A, E>(
-  effect: Effect.Effect<A, E, R>,
+export const unsafeRunPromiseExit: {
+  <R>(
+    runtime: Runtime.Runtime<R>
+  ): <A, E>(
+    effect: Effect.Effect<A, E, R>,
+    options?: { readonly signal?: AbortSignal | undefined } | undefined
+  ) => Promise<Exit.Exit<A, E>>
+  <R, A, E>(
+    runtime: Runtime.Runtime<R>,
+    effect: Effect.Effect<A, E, R>,
+    options?: { readonly signal?: AbortSignal | undefined } | undefined
+  ): Promise<Exit.Exit<A, E>>
+} = makeDual((
+  runtime,
+  effect,
   options?: {
     readonly signal?: AbortSignal | undefined
   } | undefined
-): Promise<Exit.Exit<A, E>> =>
-  new Promise((resolve) => {
+) =>
+  new Promise<Exit.Exit<any, any>>((resolve) => {
     const op = fastPath(effect)
     if (op) {
       resolve(op)
@@ -291,6 +356,7 @@ export const unsafeRunPromiseExit = <R>(runtime: Runtime.Runtime<R>) =>
       }
     }
   })
+)
 
 /** @internal */
 export class RuntimeImpl<in R> implements Runtime.Runtime<R> {

package/src/internal/tracer.ts

@@ -44,12 +44,13 @@ export class NativeSpan implements Tracer.Span {
   status: Tracer.SpanStatus
   attributes: Map<string, unknown>
   events: Array<[name: string, startTime: bigint, attributes: Record<string, unknown>]> = []
+  links: Array<Tracer.SpanLink>
 
   constructor(
     readonly name: string,
     readonly parent: Option.Option<Tracer.AnySpan>,
     readonly context: Context.Context<never>,
-    readonly links: ReadonlyArray<Tracer.SpanLink>,
+    links: Iterable<Tracer.SpanLink>,
     readonly startTime: bigint,
     readonly kind: Tracer.SpanKind
   ) {
@@ -60,6 +61,7 @@ export class NativeSpan implements Tracer.Span {
     this.attributes = new Map()
     this.traceId = parent._tag === "Some" ? parent.value.traceId : randomHexString(32)
     this.spanId = randomHexString(16)
+    this.links = Array.from(links)
   }
 
   end(endTime: bigint, exit: Exit.Exit<unknown, unknown>): void {
@@ -78,6 +80,11 @@ export class NativeSpan implements Tracer.Span {
   event(name: string, startTime: bigint, attributes?: Record<string, unknown>): void {
     this.events.push([name, startTime, attributes ?? {}])
   }
+
+  addLinks(links: ReadonlyArray<Tracer.SpanLink>): void {
+    // eslint-disable-next-line no-restricted-syntax
+    this.links.push(...links)
+  }
 }
 
 /** @internal */

package/src/internal/version.ts

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