@clayroach/effect 3.19.14-source-capture.8 → 3.19.14-source-trace.2

package/src/internal/runtime.ts

@@ -0,0 +1,558 @@
+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"
+import type * as FiberRef from "../FiberRef.js"
+import * as FiberRefs from "../FiberRefs.js"
+import { dual, pipe } from "../Function.js"
+import * as Inspectable from "../Inspectable.js"
+import * as Option from "../Option.js"
+import { pipeArguments } from "../Pipeable.js"
+import * as Predicate from "../Predicate.js"
+import type * as Runtime from "../Runtime.js"
+import type * as RuntimeFlags from "../RuntimeFlags.js"
+import * as scheduler_ from "../Scheduler.js"
+import * as scope_ from "../Scope.js"
+import * as InternalCause from "./cause.js"
+import * as core from "./core.js"
+import * as executionStrategy from "./executionStrategy.js"
+import * as FiberRuntime from "./fiberRuntime.js"
+import * as fiberScope from "./fiberScope.js"
+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>(
+    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> => {
+  const fiberId = FiberId.unsafeMake()
+  const fiberRefUpdates: ReadonlyArray.NonEmptyArray<
+    readonly [FiberRef.FiberRef<any>, ReadonlyArray.NonEmptyReadonlyArray<readonly [FiberId.Runtime, any]>]
+  > = [[core.currentContext, [[fiberId, runtime.context]]]]
+
+  if (options?.scheduler) {
+    fiberRefUpdates.push([scheduler_.currentScheduler, [[fiberId, options.scheduler]]])
+  }
+
+  let fiberRefs = FiberRefs.updateManyAs(runtime.fiberRefs, {
+    entries: fiberRefUpdates,
+    forkAs: fiberId
+  })
+
+  if (options?.updateRefs) {
+    fiberRefs = options.updateRefs(fiberRefs, fiberId)
+  }
+
+  const fiberRuntime: FiberRuntime.FiberRuntime<A, E> = new FiberRuntime.FiberRuntime<A, E>(
+    fiberId,
+    fiberRefs,
+    runtime.runtimeFlags
+  )
+
+  let effect: Effect.Effect<A, E, R> = self
+
+  if (options?.scope) {
+    effect = core.flatMap(
+      scope_.fork(options.scope, executionStrategy.sequential),
+      (closeableScope) =>
+        core.zipRight(
+          core.scopeAddFinalizer(
+            closeableScope,
+            core.fiberIdWith((id) =>
+              equals(id, fiberRuntime.id()) ? core.void : core.interruptAsFiber(fiberRuntime, id)
+            )
+          ),
+          core.onExit(self, (exit) => scope_.close(closeableScope, exit))
+        )
+    )
+  }
+
+  const supervisor = fiberRuntime.currentSupervisor
+
+  // we can compare by reference here as _supervisor.none is wrapped with globalValue
+  if (supervisor !== supervisor_.none) {
+    supervisor.onStart(runtime.context, effect, Option.none(), fiberRuntime)
+
+    fiberRuntime.addObserver((exit) => supervisor.onEnd(exit, fiberRuntime))
+  }
+
+  fiberScope.globalScope.add(runtime.runtimeFlags, fiberRuntime)
+
+  // Only an explicit false will prevent immediate execution
+  if (options?.immediate === false) {
+    fiberRuntime.resume(effect)
+  } else {
+    fiberRuntime.start(effect)
+  }
+
+  return fiberRuntime
+})
+
+/** @internal */
+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) => {
+      options.onExit!(exit)
+    })
+  }
+
+  return (id, cancelOptions) =>
+    unsafeRunCallback(runtime)(
+      pipe(fiberRuntime, Fiber.interruptAs(id ?? FiberId.none)),
+      {
+        ...cancelOptions,
+        onExit: cancelOptions?.onExit
+          ? (exit) => cancelOptions.onExit!(Exit.flatten(exit))
+          : undefined
+      }
+    )
+})
+
+/** @internal */
+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)
+  }
+  return result.effect_instruction_i0
+})
+
+class AsyncFiberExceptionImpl<A, E = never> extends Error implements Runtime.AsyncFiberException<A, E> {
+  readonly _tag = "AsyncFiberException"
+  constructor(readonly fiber: Fiber.RuntimeFiber<A, E>) {
+    super(
+      `Fiber #${fiber.id().id} cannot be resolved synchronously. This is caused by using runSync on an effect that performs async work`
+    )
+    this.name = this._tag
+    this.stack = this.message
+  }
+}
+
+const asyncFiberException = <A, E>(fiber: Fiber.RuntimeFiber<A, E>): Runtime.AsyncFiberException<A, E> => {
+  const limit = Error.stackTraceLimit
+  Error.stackTraceLimit = 0
+  const error = new AsyncFiberExceptionImpl(fiber)
+  Error.stackTraceLimit = limit
+  return error
+}
+
+/** @internal */
+export const isAsyncFiberException = (u: unknown): u is Runtime.AsyncFiberException<unknown, unknown> =>
+  Predicate.isTagged(u, "AsyncFiberException") && "fiber" in u
+
+/** @internal */
+export const FiberFailureId: Runtime.FiberFailureId = Symbol.for("effect/Runtime/FiberFailure") as any
+/** @internal */
+export const FiberFailureCauseId: Runtime.FiberFailureCauseId = Symbol.for(
+  "effect/Runtime/FiberFailure/Cause"
+) as any
+
+class FiberFailureImpl extends Error implements Runtime.FiberFailure {
+  readonly [FiberFailureId]: Runtime.FiberFailureId
+  readonly [FiberFailureCauseId]: Cause.Cause<unknown>
+  constructor(cause: Cause.Cause<unknown>) {
+    const head = InternalCause.prettyErrors(cause)[0]
+
+    super(head?.message || "An error has occurred")
+    this[FiberFailureId] = FiberFailureId
+    this[FiberFailureCauseId] = cause
+
+    this.name = head ? `(FiberFailure) ${head.name}` : "FiberFailure"
+    if (head?.stack) {
+      this.stack = head.stack
+    }
+  }
+
+  toJSON(): unknown {
+    return {
+      _id: "FiberFailure",
+      cause: this[FiberFailureCauseId].toJSON()
+    }
+  }
+
+  toString(): string {
+    return "(FiberFailure) " + InternalCause.pretty(this[FiberFailureCauseId], { renderErrorCause: true })
+  }
+  [Inspectable.NodeInspectSymbol](): unknown {
+    return this.toString()
+  }
+}
+
+/** @internal */
+export const fiberFailure = <E>(cause: Cause.Cause<E>): Runtime.FiberFailure => {
+  const limit = Error.stackTraceLimit
+  Error.stackTraceLimit = 0
+  const error = new FiberFailureImpl(cause)
+  Error.stackTraceLimit = limit
+  return error
+}
+
+/** @internal */
+export const isFiberFailure = (u: unknown): u is Runtime.FiberFailure => Predicate.hasProperty(u, FiberFailureId)
+
+const fastPath = <A, E, R>(effect: Effect.Effect<A, E, R>): Exit.Exit<A, E> | undefined => {
+  const op = effect as core.Primitive
+  switch (op._op) {
+    case "Failure":
+    case "Success": {
+      // @ts-expect-error
+      return op
+    }
+    case "Left": {
+      return core.exitFail(op.left)
+    }
+    case "Right": {
+      return core.exitSucceed(op.right)
+    }
+    case "Some": {
+      return core.exitSucceed(op.value)
+    }
+    case "None": {
+      // @ts-expect-error
+      return core.exitFail(new core.NoSuchElementException())
+    }
+  }
+}
+
+/** @internal */
+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>,
+    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
+) =>
+  unsafeRunPromiseExit(runtime, effect, options).then((result) => {
+    switch (result._tag) {
+      case OpCodes.OP_SUCCESS: {
+        return result.effect_instruction_i0
+      }
+      case OpCodes.OP_FAILURE: {
+        throw fiberFailure(result.effect_instruction_i0)
+      }
+    }
+  })
+)
+
+/** @internal */
+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
+) =>
+  new Promise<Exit.Exit<any, any>>((resolve) => {
+    const op = fastPath(effect)
+    if (op) {
+      resolve(op)
+    }
+    const fiber = unsafeFork(runtime)(effect)
+    fiber.addObserver((exit) => {
+      resolve(exit)
+    })
+    if (options?.signal !== undefined) {
+      if (options.signal.aborted) {
+        fiber.unsafeInterruptAsFork(fiber.id())
+      } else {
+        options.signal.addEventListener("abort", () => {
+          fiber.unsafeInterruptAsFork(fiber.id())
+        }, { once: true })
+      }
+    }
+  })
+)
+
+/** @internal */
+export class RuntimeImpl<in R> implements Runtime.Runtime<R> {
+  constructor(
+    readonly context: Context.Context<R>,
+    readonly runtimeFlags: RuntimeFlags.RuntimeFlags,
+    readonly fiberRefs: FiberRefs.FiberRefs
+  ) {}
+
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+/** @internal */
+export const make = <R>(
+  options: {
+    readonly context: Context.Context<R>
+    readonly runtimeFlags: RuntimeFlags.RuntimeFlags
+    readonly fiberRefs: FiberRefs.FiberRefs
+  }
+): Runtime.Runtime<R> => new RuntimeImpl(options.context, options.runtimeFlags, options.fiberRefs)
+
+/** @internal */
+export const runtime = <R>(): Effect.Effect<Runtime.Runtime<R>, never, R> =>
+  core.withFiberRuntime((state, status) =>
+    core.succeed(
+      new RuntimeImpl<R>(
+        state.getFiberRef(core.currentContext as unknown as FiberRef.FiberRef<Context.Context<R>>),
+        status.runtimeFlags,
+        state.getFiberRefs()
+      )
+    )
+  )
+
+/** @internal */
+export const defaultRuntimeFlags: RuntimeFlags.RuntimeFlags = runtimeFlags.make(
+  runtimeFlags.Interruption,
+  runtimeFlags.CooperativeYielding,
+  runtimeFlags.RuntimeMetrics
+)
+
+/** @internal */
+export const defaultRuntime = make({
+  context: Context.empty(),
+  runtimeFlags: defaultRuntimeFlags,
+  fiberRefs: FiberRefs.empty()
+})
+
+/** @internal */
+export const updateRuntimeFlags: {
+  (
+    f: (flags: RuntimeFlags.RuntimeFlags) => RuntimeFlags.RuntimeFlags
+  ): <R>(self: Runtime.Runtime<R>) => Runtime.Runtime<R>
+  <R>(self: Runtime.Runtime<R>, f: (flags: RuntimeFlags.RuntimeFlags) => RuntimeFlags.RuntimeFlags): Runtime.Runtime<R>
+} = dual(
+  2,
+  <R>(self: Runtime.Runtime<R>, f: (flags: RuntimeFlags.RuntimeFlags) => RuntimeFlags.RuntimeFlags) =>
+    make({
+      context: self.context,
+      runtimeFlags: f(self.runtimeFlags),
+      fiberRefs: self.fiberRefs
+    })
+)
+
+/** @internal */
+export const disableRuntimeFlag: {
+  (flag: RuntimeFlags.RuntimeFlag): <R>(self: Runtime.Runtime<R>) => Runtime.Runtime<R>
+  <R>(self: Runtime.Runtime<R>, flag: RuntimeFlags.RuntimeFlag): Runtime.Runtime<R>
+} = dual(
+  2,
+  <R>(self: Runtime.Runtime<R>, flag: RuntimeFlags.RuntimeFlag) => updateRuntimeFlags(self, runtimeFlags.disable(flag))
+)
+
+/** @internal */
+export const enableRuntimeFlag: {
+  (flag: RuntimeFlags.RuntimeFlag): <R>(self: Runtime.Runtime<R>) => Runtime.Runtime<R>
+  <R>(self: Runtime.Runtime<R>, flag: RuntimeFlags.RuntimeFlag): Runtime.Runtime<R>
+} = dual(
+  2,
+  <R>(self: Runtime.Runtime<R>, flag: RuntimeFlags.RuntimeFlag) => updateRuntimeFlags(self, runtimeFlags.enable(flag))
+)
+
+/** @internal */
+export const updateContext: {
+  <R, R2>(f: (context: Context.Context<R>) => Context.Context<R2>): (self: Runtime.Runtime<R>) => Runtime.Runtime<R2>
+  <R, R2>(self: Runtime.Runtime<R>, f: (context: Context.Context<R>) => Context.Context<R2>): Runtime.Runtime<R2>
+} = dual(
+  2,
+  <R, R2>(self: Runtime.Runtime<R>, f: (context: Context.Context<R>) => Context.Context<R2>) =>
+    make({
+      context: f(self.context),
+      runtimeFlags: self.runtimeFlags,
+      fiberRefs: self.fiberRefs
+    })
+)
+
+/** @internal */
+export const provideService: {
+  <I, S>(tag: Context.Tag<I, S>, service: S): <R>(self: Runtime.Runtime<R>) => Runtime.Runtime<R | I>
+  <R, I, S>(self: Runtime.Runtime<R>, tag: Context.Tag<I, S>, service: S): Runtime.Runtime<R | I>
+} = dual(
+  3,
+  <R, I, S>(self: Runtime.Runtime<R>, tag: Context.Tag<I, S>, service: S) =>
+    updateContext(self, Context.add(tag, service))
+)
+
+/** @internal */
+export const updateFiberRefs: {
+  (f: (fiberRefs: FiberRefs.FiberRefs) => FiberRefs.FiberRefs): <R>(self: Runtime.Runtime<R>) => Runtime.Runtime<R>
+  <R>(self: Runtime.Runtime<R>, f: (fiberRefs: FiberRefs.FiberRefs) => FiberRefs.FiberRefs): Runtime.Runtime<R>
+} = dual(
+  2,
+  <R>(self: Runtime.Runtime<R>, f: (fiberRefs: FiberRefs.FiberRefs) => FiberRefs.FiberRefs): Runtime.Runtime<R> =>
+    make({
+      context: self.context,
+      runtimeFlags: self.runtimeFlags,
+      fiberRefs: f(self.fiberRefs)
+    })
+)
+
+/** @internal */
+export const setFiberRef: {
+  <A>(fiberRef: FiberRef.FiberRef<A>, value: A): <R>(self: Runtime.Runtime<R>) => Runtime.Runtime<R>
+  <R, A>(self: Runtime.Runtime<R>, fiberRef: FiberRef.FiberRef<A>, value: A): Runtime.Runtime<R>
+} = dual(
+  3,
+  <R, A>(self: Runtime.Runtime<R>, fiberRef: FiberRef.FiberRef<A>, value: A): Runtime.Runtime<R> =>
+    updateFiberRefs(
+      self,
+      FiberRefs.updateAs({
+        fiberId: FiberId.none,
+        fiberRef,
+        value
+      })
+    )
+)
+
+/** @internal */
+export const deleteFiberRef: {
+  <A>(fiberRef: FiberRef.FiberRef<A>): <R>(self: Runtime.Runtime<R>) => Runtime.Runtime<R>
+  <R, A>(self: Runtime.Runtime<R>, fiberRef: FiberRef.FiberRef<A>): Runtime.Runtime<R>
+} = dual(
+  2,
+  <R, A>(self: Runtime.Runtime<R>, fiberRef: FiberRef.FiberRef<A>): Runtime.Runtime<R> =>
+    updateFiberRefs(self, FiberRefs.delete(fiberRef))
+)
+
+/** @internal */
+export const unsafeRunEffect = unsafeRunCallback(defaultRuntime)
+
+/** @internal */
+export const unsafeForkEffect = unsafeFork(defaultRuntime)
+
+/** @internal */
+export const unsafeRunPromiseEffect = unsafeRunPromise(defaultRuntime)
+
+/** @internal */
+export const unsafeRunPromiseExitEffect = unsafeRunPromiseExit(defaultRuntime)
+
+/** @internal */
+export const unsafeRunSyncEffect = unsafeRunSync(defaultRuntime)
+
+/** @internal */
+export const unsafeRunSyncExitEffect = unsafeRunSyncExit(defaultRuntime)
+
+// circular with Effect
+
+/** @internal */
+export const asyncEffect = <A, E, R, R3, E2, R2>(
+  register: (
+    callback: (_: Effect.Effect<A, E, R>) => void
+  ) => Effect.Effect<Effect.Effect<void, never, R3> | void, E2, R2>
+): Effect.Effect<A, E | E2, R | R2 | R3> =>
+  core.suspend(() => {
+    let cleanup: Effect.Effect<void, never, R3> | void = undefined
+    return core.flatMap(
+      core.deferredMake<A, E | E2>(),
+      (deferred) =>
+        core.flatMap(runtime<R | R2 | R3>(), (runtime) =>
+          core.uninterruptibleMask((restore) =>
+            core.zipRight(
+              FiberRuntime.fork(restore(
+                core.matchCauseEffect(
+                  register((cb) => unsafeRunCallback(runtime)(core.intoDeferred(cb, deferred))),
+                  {
+                    onFailure: (cause) => core.deferredFailCause(deferred, cause),
+                    onSuccess: (cleanup_) => {
+                      cleanup = cleanup_
+                      return core.void
+                    }
+                  }
+                )
+              )),
+              restore(core.onInterrupt(core.deferredAwait(deferred), () => cleanup ?? core.void))
+            )
+          ))
+    )
+  })