Function handleForbidden

packages/effect/src/ParseResult.ts:1609–1653

(
  effect: Effect.Effect<A, ParseIssue, R>,
  ast: AST.AST,
  actual: unknown,
  options: InternalOptions | undefined
)

const dropRightRefinement = (ast: AST.AST): AST.AST => AST.isRefinement(ast) ? dropRightRefinement(ast.from) : ast

const handleForbidden = <A, R>(
  effect: Effect.Effect<A, ParseIssue, R>,
  ast: AST.AST,
  actual: unknown,
  options: InternalOptions | undefined
): Effect.Effect<A, ParseIssue, R> => {
  // If effects are allowed, return the original effect
  if (options?.isEffectAllowed === true) {
    return effect
  }

  // If the effect is already an Either, return it directly
  if (isEither(effect)) {
    return effect
  }

  // Otherwise, attempt to execute the effect synchronously
  const scheduler = new Scheduler.SyncScheduler()
  const fiber = Effect.runFork(effect as Effect.Effect<A, ParseIssue>, { scheduler })
  scheduler.flush()
  const exit = fiber.unsafePoll()

  if (exit) {
    if (Exit.isSuccess(exit)) {
      // If the effect successfully resolves, wrap the value in a Right
      return Either.right(exit.value)
    }
    const cause = exit.cause
    if (Cause.isFailType(cause)) {
      // The effect executed synchronously but failed due to a ParseIssue
      return Either.left(cause.error)
    }
    // The effect executed synchronously but failed due to a defect (e.g., a missing dependency)
    return Either.left(new Forbidden(ast, actual, Cause.pretty(cause)))
  }

  // The effect could not be resolved synchronously, meaning it performs async work
  return Either.left(
    new Forbidden(
      ast,
      actual,
      "cannot be be resolved synchronously, this is caused by using runSync on an effect that performs async work"
    )
  )
}

const compare = ([a]: [number, ...Array<unknown>], [b]: [number, ...Array<unknown>]) => a > b ? 1 : a < b ? -1 : 0