@typed/fx 1.19.0 → 1.20.1

package/src/internal/loop-operator.ts

@@ -0,0 +1,266 @@
+import type { Either } from "effect"
+import * as Option from "effect/Option"
+import * as Sink from "../Sink.js"
+import type { Bounds } from "./bounds.js"
+import * as SyncOp from "./sync-operator.js"
+
+export type SyncLoopOperator<B = any, A = any, C = any> =
+  | LoopOperator<B, A, C>
+  | FilterMapLoopOperator<B, A, C>
+
+export interface LoopOperator<B, A, C> {
+  readonly _tag: "Loop"
+  readonly seed: B
+  readonly f: (acc: B, a: A) => readonly [C, B]
+}
+
+export function LoopOperator<const B, A, C>(seed: B, f: (acc: B, a: A) => readonly [C, B]): LoopOperator<B, A, C> {
+  return { _tag: "Loop", seed, f }
+}
+
+export interface FilterMapLoopOperator<B, A, C> {
+  readonly _tag: "FilterMapLoop"
+  readonly seed: B
+  readonly f: (acc: B, a: A) => readonly [Option.Option<C>, B]
+}
+
+export function FilterMapLoopOperator<const B, A, C>(
+  seed: B,
+  f: (acc: B, a: A) => readonly [Option.Option<C>, B]
+): FilterMapLoopOperator<B, A, C> {
+  return { _tag: "FilterMapLoop", seed, f }
+}
+
+export interface SliceOperator {
+  readonly _tag: "Slice"
+  readonly bounds: Bounds
+}
+
+export function SliceOperator(bounds: Bounds): SliceOperator {
+  return { _tag: "Slice", bounds }
+}
+
+export interface FilterMapSliceOperator<A, B, C> {
+  readonly _tag: "FilterMapSlice"
+  readonly seed: B
+  readonly f: (acc: B, a: A) => Either.Either<Option.Option<C>, readonly [Option.Option<C>, B]>
+}
+
+export function FilterMapSliceOperator<const B, A, C>(
+  seed: B,
+  f: (acc: B, a: A) => Either.Either<Option.Option<C>, readonly [Option.Option<C>, B]>
+): FilterMapSliceOperator<A, B, C> {
+  return { _tag: "FilterMapSlice", seed, f }
+}
+
+export function matchSyncLoopOperator<A, B, C, D>(operator: SyncLoopOperator<A, B, C>, matchers: {
+  Loop: (op: LoopOperator<A, B, C>) => D
+  FilterMapLoop: (op: FilterMapLoopOperator<A, B, C>) => D
+}): D {
+  if (operator._tag === "Loop") {
+    return matchers.Loop(operator)
+  } else {
+    return matchers.FilterMapLoop(operator)
+  }
+}
+
+export function fuseSyncOperatorBefore(
+  syncOp: SyncOp.SyncOperator,
+  loopOp: SyncLoopOperator
+): SyncLoopOperator {
+  return SyncOp.matchSyncOperator(syncOp, {
+    Map: (op): SyncLoopOperator =>
+      matchSyncLoopOperator(loopOp, {
+        Loop: (lOp): SyncLoopOperator => LoopOperator(lOp.seed, (acc, a) => lOp.f(acc, op.f(a))),
+        FilterMapLoop: (lOp) => FilterMapLoopOperator(lOp.seed, (acc, a) => lOp.f(acc, op.f(a)))
+      }),
+    Filter: (op) =>
+      matchSyncLoopOperator(loopOp, {
+        Loop: (lOp): SyncLoopOperator =>
+          FilterMapLoopOperator(lOp.seed, (acc, a) => {
+            const [b, c] = lOp.f(acc, a)
+            if (op.f(b)) {
+              return [Option.some(b), c]
+            } else {
+              return [Option.none(), c]
+            }
+          }),
+        FilterMapLoop: (lOp) =>
+          FilterMapLoopOperator(lOp.seed, (acc, a) => {
+            if (op.f(a)) {
+              return [Option.none(), acc]
+            } else {
+              return lOp.f(acc, a)
+            }
+          })
+      }),
+    FilterMap: (op) =>
+      matchSyncLoopOperator(loopOp, {
+        Loop: (lOp): SyncLoopOperator =>
+          FilterMapLoopOperator(lOp.seed, (acc, a) => {
+            const x = op.f(a)
+
+            if (Option.isNone(x)) {
+              return [Option.none(), acc]
+            } else {
+              const [b, c] = lOp.f(acc, x.value)
+              return [Option.some(b), c]
+            }
+          }),
+        FilterMapLoop: (lOp) =>
+          FilterMapLoopOperator(lOp.seed, (acc, a) => {
+            const x = op.f(a)
+
+            if (Option.isNone(x)) {
+              return [Option.none(), acc]
+            } else {
+              return lOp.f(acc, x.value)
+            }
+          })
+      })
+  })
+}
+
+export function fuseSyncOperatorAfter(
+  loopOp: SyncLoopOperator,
+  syncOp: SyncOp.SyncOperator
+): SyncLoopOperator {
+  return matchSyncLoopOperator(loopOp, {
+    Loop: (loopOp) =>
+      SyncOp.matchSyncOperator(syncOp, {
+        Map: (op): SyncLoopOperator =>
+          LoopOperator(loopOp.seed, (acc, a) => {
+            const [b, c] = loopOp.f(acc, a)
+            return [op.f(b), c]
+          }),
+        Filter: (op) =>
+          FilterMapLoopOperator(loopOp.seed, (acc, a) => {
+            const [b, c] = loopOp.f(acc, a)
+            if (op.f(b)) {
+              return [Option.some(b), c]
+            } else {
+              return [Option.none(), c]
+            }
+          }),
+        FilterMap: (op) =>
+          FilterMapLoopOperator(loopOp.seed, (acc, a) => {
+            const [b, c] = loopOp.f(acc, a)
+            return Option.match(op.f(b), {
+              onNone: () => [Option.none(), c],
+              onSome: (d) => [Option.some(d), c]
+            })
+          })
+      }),
+    FilterMapLoop: (loopOp) =>
+      SyncOp.matchSyncOperator(syncOp, {
+        Map: (op): SyncLoopOperator =>
+          FilterMapLoopOperator(loopOp.seed, (acc, a) => {
+            const [b, c] = loopOp.f(acc, a)
+            return [Option.map(b, op.f), c]
+          }),
+        Filter: (op) =>
+          FilterMapLoopOperator(loopOp.seed, (acc, a) => {
+            const [b, c] = loopOp.f(acc, a)
+            return [Option.filter(b, op.f), c]
+          }),
+        FilterMap: (op) =>
+          FilterMapLoopOperator(loopOp.seed, (acc, a) => {
+            const [b, c] = loopOp.f(acc, a)
+            return [Option.flatMap(b, op.f), c]
+          })
+      })
+  })
+}
+
+export function fuseLoopOperators<A, B, C, D, E>(
+  first: SyncLoopOperator<A, B, C>,
+  second: SyncLoopOperator<D, C, E>
+): SyncLoopOperator<readonly [A, D], B, E> {
+  return matchSyncLoopOperator(first, {
+    Loop: (op1) =>
+      matchSyncLoopOperator(second, {
+        Loop: (op2): SyncLoopOperator<readonly [A, D], B, E> =>
+          LoopOperator([op1.seed, op2.seed], ([accA, accB], a: B) => {
+            const [c, b] = op1.f(accA, a)
+            const [e, d] = op2.f(accB, c)
+            return [e, [b, d]]
+          }),
+        FilterMapLoop: (op2) =>
+          FilterMapLoopOperator([op1.seed, op2.seed], ([accA, accB], a) => {
+            const [c, b] = op1.f(accA, a)
+            const [e, d] = op2.f(accB, c)
+            return [e, [b, d]]
+          })
+      }),
+    FilterMapLoop: (op1) =>
+      matchSyncLoopOperator(second, {
+        Loop: (op2): SyncLoopOperator<readonly [A, D], B, E> =>
+          FilterMapLoopOperator([op1.seed, op2.seed], ([accA, accB], a: B) => {
+            const [c, b] = op1.f(accA, a)
+            if (Option.isNone(c)) {
+              return [Option.none(), [b, accB]] as const
+            }
+            const [e, d] = op2.f(accB, c.value)
+            return [Option.some(e), [b, d]] as const
+          }),
+        FilterMapLoop: (op2) =>
+          FilterMapLoopOperator([op1.seed, op2.seed], ([accA, accB], a) => {
+            const [c, b] = op1.f(accA, a)
+            if (Option.isNone(c)) {
+              return [Option.none(), [b, accB]]
+            }
+            const [e, d] = op2.f(accB, c.value)
+            return [e, [b, d]]
+          })
+      })
+  })
+}
+
+export function compileLoopOperatorSink<R>(operator: SyncLoopOperator, sink: Sink.Sink<R, any, any>) {
+  return matchSyncLoopOperator(operator, {
+    Loop: (op) => Sink.loop(sink, op.seed, op.f),
+    FilterMapLoop: (op) => Sink.filterMapLoop(sink, op.seed, op.f)
+  })
+}
+
+export function compileCauseLoopOperatorSink<R>(operator: SyncLoopOperator, sink: Sink.Sink<R, any, any>) {
+  return matchSyncLoopOperator(operator, {
+    Loop: (op) => Sink.loopCause(sink, op.seed, op.f),
+    FilterMapLoop: (op) => Sink.filterMapLoopCause(sink, op.seed, op.f)
+  })
+}
+
+export function applyArray<A, B>(array: ReadonlyArray<A>, operator: SyncLoopOperator): ReadonlyArray<B> {
+  return matchSyncLoopOperator(operator, {
+    Loop: (op) => loopArray(array, op.seed, op.f),
+    FilterMapLoop: (op) => filterMapLoopArray(array, op.seed, op.f)
+  })
+}
+
+function loopArray<A, B, C>(array: ReadonlyArray<A>, seed: B, f: (acc: B, a: A) => readonly [C, B]): ReadonlyArray<C> {
+  const result = new Array<C>(array.length)
+  let acc = seed
+  for (let i = 0; i < array.length; i++) {
+    const [c, b] = f(acc, array[i])
+    result[i] = c
+    acc = b
+  }
+  return result
+}
+
+function filterMapLoopArray<A, B, C>(
+  array: ReadonlyArray<A>,
+  seed: B,
+  f: (acc: B, a: A) => readonly [Option.Option<C>, B]
+): ReadonlyArray<C> {
+  const result = new Array<C>()
+  let acc = seed
+  for (let i = 0; i < array.length; i++) {
+    const [option, b] = f(acc, array[i])
+    if (Option.isSome(option)) {
+      result.push(option.value)
+    }
+    acc = b
+  }
+  return result
+}

package/src/internal/operator.ts

@@ -0,0 +1,87 @@
+import type { Sink } from "../Sink"
+import * as EffectLoopOp from "./effect-loop-operator.js"
+import * as EffectOp from "./effect-operator.js"
+import * as LoopOp from "./loop-operator.js"
+import * as SyncOp from "./sync-operator.js"
+
+export type Operator =
+  | SyncOp.SyncOperator
+  | EffectOp.EffectOperator
+  | LoopOp.SyncLoopOperator
+  | EffectLoopOp.EffectLoopOperator
+
+export function matchOperator<A>(operator: Operator, matchers: {
+  SyncOperator: (op: SyncOp.SyncOperator) => A
+  EffectOperator: (op: EffectOp.EffectOperator) => A
+  SyncLoopOperator: (op: LoopOp.SyncLoopOperator) => A
+  EffectLoopOperator: (op: EffectLoopOp.EffectLoopOperator) => A
+}): A {
+  switch (operator._tag) {
+    case "Map":
+    case "Filter":
+    case "FilterMap":
+      return matchers.SyncOperator(operator)
+    case "MapEffect":
+    case "TapEffect":
+    case "FilterEffect":
+    case "FilterMapEffect":
+      return matchers.EffectOperator(operator)
+    case "Loop":
+    case "FilterMapLoop":
+      return matchers.SyncLoopOperator(operator)
+    case "LoopEffect":
+    case "FilterMapLoopEffect":
+      return matchers.EffectLoopOperator(operator)
+  }
+}
+
+export function fuseOperators(first: Operator, second: Operator): Operator {
+  return matchOperator(first, {
+    SyncOperator: (op1) =>
+      matchOperator(second, {
+        SyncOperator: (op2): Operator => SyncOp.fuseSyncOperators(op1, op2),
+        EffectOperator: (op2) => EffectOp.fuseEffectOperators(EffectOp.liftSyncOperator(op1), op2),
+        SyncLoopOperator: (op2) => LoopOp.fuseSyncOperatorBefore(op1, op2),
+        EffectLoopOperator: (op2) => EffectLoopOp.fuseSyncOperatorBefore(op1, op2)
+      }),
+    EffectOperator: (op1) =>
+      matchOperator(second, {
+        SyncOperator: (op2): Operator => EffectOp.fuseEffectOperators(op1, EffectOp.liftSyncOperator(op2)),
+        EffectOperator: (op2) => EffectOp.fuseEffectOperators(op1, op2),
+        SyncLoopOperator: (op2) => EffectLoopOp.fuseEffectOperatorBefore(op1, EffectLoopOp.liftLoopOperator(op2)),
+        EffectLoopOperator: (op2) => EffectLoopOp.fuseEffectOperatorBefore(op1, op2)
+      }),
+    SyncLoopOperator: (op1) =>
+      matchOperator(second, {
+        SyncOperator: (op2): Operator => LoopOp.fuseSyncOperatorAfter(op1, op2),
+        EffectOperator: (op2) => EffectLoopOp.fuseEffectOperatorAfter(EffectLoopOp.liftLoopOperator(op1), op2),
+        SyncLoopOperator: (op2) => LoopOp.fuseLoopOperators(op1, op2),
+        EffectLoopOperator: (op2) => EffectLoopOp.fuseSyncLoopOperatorBefore(op1, op2)
+      }),
+    EffectLoopOperator: (op1) =>
+      matchOperator(second, {
+        SyncOperator: (op2): Operator => EffectLoopOp.fuseSyncOperatorAfter(op1, op2),
+        EffectOperator: (op2) => EffectLoopOp.fuseEffectOperatorAfter(op1, op2),
+        SyncLoopOperator: (op2) => EffectLoopOp.fuseSyncLoopOperatorAfter(op1, op2),
+        EffectLoopOperator: (op2) => EffectLoopOp.fuseLoopEffectOperators(op1, op2)
+      })
+  })
+}
+
+export function compileOperatorSink<R, R2>(operator: Operator, sink: Sink<R, any, any>): Sink<R | R2, any, any> {
+  return matchOperator(operator, {
+    SyncOperator: (op) => SyncOp.compileSyncOperatorSink(op, sink),
+    EffectOperator: (op) => EffectOp.compileEffectOperatorSink(op, sink),
+    SyncLoopOperator: (op) => LoopOp.compileLoopOperatorSink(op, sink),
+    EffectLoopOperator: (op) => EffectLoopOp.compileLoopEffectOperatorSink(op, sink)
+  })
+}
+
+export function compileOperatorSinkCause<R, R2>(operator: Operator, sink: Sink<R, any, any>): Sink<R | R2, any, any> {
+  return matchOperator(operator, {
+    SyncOperator: (op) => SyncOp.compileCauseSyncOperatorSink(op, sink),
+    EffectOperator: (op) => EffectOp.compileCauseEffectOperatorSink(op, sink),
+    SyncLoopOperator: (op) => LoopOp.compileCauseLoopOperatorSink(op, sink),
+    EffectLoopOperator: (op) => EffectLoopOp.compileCauseLoopEffectOperatorSinkCause(op, sink)
+  })
+}

package/src/internal/protos.ts

@@ -1,132 +1,57 @@
-import * as Effect from "effect/Effect"
-import * as Equal from "effect/Equal"
+import type { Effect } from "effect"
+import * as Effectable from "effect/Effectable"
 import { identity } from "effect/Function"
-import * as Hash from "effect/Hash"
 import { pipeArguments } from "effect/Pipeable"
-
-import { Effectable } from "effect"
-import * as Fiber from "effect/Fiber"
-import { NodeInspectSymbol } from "effect/Inspectable"
-import type { Inspectable } from "effect/Inspectable"
-import type { Fx, ToFx } from "../Fx.js"
+import type { Fx } from "../Fx.js"
+import type { Sink } from "../Sink.js"
 import { TypeId } from "../TypeId.js"
 
-export const Variance: Fx<any, any, any>[TypeId] = {
+const Variance: Fx.Variance<never, never, never> = {
   _R: identity,
   _E: identity,
   _A: identity
 }
 
-export abstract class BaseProto implements Equal.Equal, Hash.Hash, Inspectable {
-  [Equal.symbol](that: unknown) {
-    return this === that
-  }
+export abstract class FxBase<R, E, A> implements Fx<R, E, A> {
+  readonly [TypeId]: Fx.Variance<R, E, A> = Variance
 
-  [Hash.symbol]() {
-    return Hash.random(this)
-  }
+  abstract run<R2>(sink: Sink<R2, E, A>): Effect.Effect<R | R2, never, unknown>
 
   pipe() {
     return pipeArguments(this, arguments)
   }
-
-  toJSON(): unknown {
-    return this
-  }
-
-  [NodeInspectSymbol]() {
-    return this.toJSON()
-  }
-
-  toString() {
-    return JSON.stringify(this.toJSON())
-  }
 }
 
-export abstract class FxProto<R, E, A> extends BaseProto implements Fx<R, E, A> {
-  abstract readonly _fxTag: string
-  readonly [TypeId]: Fx<R, E, A>[TypeId] = Variance
-
-  constructor(
-    readonly i0?: unknown,
-    readonly i1?: unknown,
-    readonly i2?: unknown
-  ) {
-    super()
-  }
-
-  [Equal.symbol](that: unknown) {
-    return this === that
-  }
-
-  [Hash.symbol]() {
-    return Hash.random(this)
-  }
-
-  toJSON(): unknown {
-    return this
-  }
-
-  pipe() {
-    return pipeArguments(this, arguments)
-  }
-}
+export abstract class FxEffectBase<R, E, A, R2, E2, B> extends Effectable.StructuralClass<R2, E2, B>
+  implements Fx<R, E, A>, Effect.Effect<R2, E2, B>
+{
+  readonly [TypeId]: Fx.Variance<R, E, A> = Variance
 
-export class OnceEffect<R, E, A> extends Effectable.Class<R, E, A> {
-  #fiber: Fiber.Fiber<E, A> | undefined
+  abstract run<R3>(sink: Sink<R3, E, A>): Effect.Effect<R | R3, never, unknown>
 
-  constructor(
-    readonly effect: Effect.Effect<R, E, A>
-  ) {
-    super()
-  }
+  abstract toEffect(): Effect.Effect<R2, E2, B>
 
-  commit() {
-    if (this.#fiber) {
-      return Fiber.join(this.#fiber)
+  protected _effect: Effect.Effect<R2, E2, B> | undefined
+  commit(): Effect.Effect<R2, E2, B> {
+    if (this._effect === undefined) {
+      return (this._effect = this.toEffect())
     } else {
-      return Effect.forkDaemon(this.effect).pipe(
-        Effect.tap((fiber) => Effect.sync(() => this.#fiber = fiber)),
-        Effect.flatMap(Fiber.join)
-      )
+      return this._effect
     }
   }
 }
 
-export const once = <R, E, A>(effect: Effect.Effect<R, E, A>): Effect.Effect<R, E, A> => new OnceEffect(effect)
-
-// @ts-expect-error private properties don't quite work out
-export abstract class FxEffectBase<R, E, A, R2, E2, B> extends Effectable.StructuralClass<R2, E2, B>
-  implements ToFx<R, E, A>
+export abstract class EffectBase<R, E, A> extends Effectable.StructuralClass<R, E, A>
+  implements Effect.Effect<R, E, A>
 {
-  _fxTag = "ToFx" as const
-
-  readonly [TypeId] = Variance as any
-
-  protected abstract toFx(): Fx<R, E, A>
-  protected abstract toEffect(): Effect.Effect<R2, E2, B>
-
-  private _fx: Fx<R, E, A> | undefined
-
-  get fx(): Fx<R, E, A> {
-    return this._fx ||= this.toFx()
-  }
+  abstract toEffect(): Effect.Effect<R, E, A>
 
-  private _effect: Effect.Effect<R2, E2, B> | undefined
-
-  commit(): Effect.Effect<R2, E2, B> {
-    return this._effect ||= this.toEffect()
-  }
-
-  toJSON(): unknown {
-    return this
-  }
-
-  [NodeInspectSymbol]() {
-    return this.toJSON()
-  }
-
-  toString() {
-    return JSON.stringify(this.toJSON())
+  private _effect: Effect.Effect<R, E, A> | undefined
+  commit(): Effect.Effect<R, E, A> {
+    if (this._effect === undefined) {
+      return (this._effect = this.toEffect())
+    } else {
+      return this._effect
+    }
   }
 }

package/src/internal/provide.ts

@@ -1,5 +1,10 @@
 import type * as Context from "@typed/context"
-import { Effect, FiberRefsPatch, Layer, Runtime, RuntimeFlags } from "effect"
+import * as Effect from "effect/Effect"
+import * as FiberRefsPatch from "effect/FiberRefsPatch"
+import * as Layer from "effect/Layer"
+import * as Runtime from "effect/Runtime"
+import * as RuntimeFlags from "effect/RuntimeFlags"
+import type * as Scope from "effect/Scope"
 
 export type Provide<R, E, A> =
   | ProvideContext<A>
@@ -82,62 +87,65 @@ export function merge<R = never, E = never, A = never, R2 = never, E2 = never, B
   self: Provide<R, E, A>,
   that: Provide<R2, E2, B>
 ): Provide<Exclude<R, B> | R2, E | E2, A | B> {
-  return matchProvide(self, {
-    ProvideContext: (a) => mergeLayer(Layer.succeedContext(a), that),
-    ProvideLayer: (a) => mergeLayer(a, that),
-    ProvideRuntime: (a) => mergeLayer(runtimeToLayer(a), that),
-    ProvideService: (tag, service) => mergeLayer(Layer.succeed(tag, service), that),
-    ProvideServiceEffect: (tag, service) => mergeLayer(Layer.effect(tag, service), that)
-  })
+  return ProvideLayer(Layer.provideMerge(toLayer(self), toLayer(that)))
 }
 
-function mergeLayer<R, E, A, R2, E2, B>(
-  layer: Layer.Layer<R, E, A>,
-  provide: Provide<R2, E2, B>
-): Provide<Exclude<R, B> | R2, E | E2, A | B> {
-  return matchProvide(provide, {
-    ProvideContext: (ctx) => ProvideLayer(Layer.provideMerge(layer, Layer.succeedContext(ctx))),
-    ProvideLayer: (layerB) => ProvideLayer(Layer.provideMerge(layer, layerB)),
-    ProvideRuntime: (runtime) => ProvideLayer(Layer.provideMerge(layer, runtimeToLayer(runtime))),
-    ProvideService: (tag, service) => ProvideLayer(Layer.provideMerge(layer, Layer.succeed(tag, service))),
-    ProvideServiceEffect: (tag, service) => ProvideLayer(Layer.provideMerge(layer, Layer.effect(tag, service)))
-  })
+export function buildWithScope<R, E, A>(
+  provide: Provide<R, E, A>,
+  scope: Scope.Scope
+) {
+  return Layer.buildWithScope(toLayer(provide), scope)
 }
 
-export function provideToEffect<R, E, A, R2 = never, E2 = never, S = never>(
-  effect: Effect.Effect<R, E, A>,
-  provide: Provide<R2, E2, S>
-): Effect.Effect<Exclude<R, S> | R2, E | E2, A> {
+export function toLayer<R, E, A>(provide: Provide<R, E, A>): Layer.Layer<R, E, A> {
   switch (provide._tag) {
     case "ProvideContext":
+      return Layer.succeedContext(provide.i0)
     case "ProvideLayer":
+      return provide.i0
     case "ProvideRuntime":
-      return Effect.provide(effect, provide.i0 as Layer.Layer<R2, E2, S>)
+      return runtimeToLayer(provide.i0)
     case "ProvideService":
-      return Effect.provideService(effect, provide.i0, provide.i1)
+      return Layer.succeed(provide.i0, provide.i1)
     case "ProvideServiceEffect":
-      return Effect.provideServiceEffect(effect, provide.i0, provide.i1)
+      return Layer.effect(provide.i0, provide.i1)
   }
 }
 
-function runtimeToLayer<R>(runtime: Runtime.Runtime<R>): Layer.Layer<never, never, R> {
-  const patchFlags = RuntimeFlags.diff(Runtime.defaultRuntime.runtimeFlags, runtime.runtimeFlags)
-  const inversePatchFlags = RuntimeFlags.diff(runtime.runtimeFlags, Runtime.defaultRuntime.runtimeFlags)
+export function provideToEffect<R, E, A, R2 = never, E2 = never, S = never>(
+  effect: Effect.Effect<R, E, A>,
+  provide: Provide<R2, E2, S>
+): Effect.Effect<Exclude<R, S> | R2, E | E2, A> {
+  return Effect.provide(effect, toLayer(provide))
+}
+
+export function runtimeToLayer<R>(runtime: Runtime.Runtime<R>): Layer.Layer<never, never, R> {
+  // Calculate patch
   const patchRefs = FiberRefsPatch.diff(Runtime.defaultRuntime.fiberRefs, runtime.fiberRefs)
-  const inversePatchRefs = FiberRefsPatch.diff(runtime.fiberRefs, Runtime.defaultRuntime.fiberRefs)
+  const patchFlags = RuntimeFlags.diff(Runtime.defaultRuntime.runtimeFlags, runtime.runtimeFlags)
 
   return Layer.scopedContext(
-    Effect.acquireUseRelease(
-      Effect.flatMap(
-        Effect.patchRuntimeFlags(patchFlags),
-        () => Effect.patchFiberRefs(patchRefs)
-      ),
-      () => Effect.succeed(runtime.context),
-      () =>
-        Effect.flatMap(
-          Effect.patchRuntimeFlags(inversePatchFlags),
-          () => Effect.patchFiberRefs(inversePatchRefs)
+    Effect.Do.pipe(
+      // Get Current Refs + Flags
+      Effect.bind("oldRefs", () => Effect.getFiberRefs),
+      Effect.bind("oldFlags", () => Effect.getRuntimeFlags),
+      // Patch Refs + Flags
+      Effect.tap(() => Effect.patchFiberRefs(patchRefs)),
+      Effect.tap(() => Effect.patchRuntimeFlags(patchFlags)),
+      // Get the new Refs + Flags
+      Effect.bind("newRefs", () => Effect.getFiberRefs),
+      Effect.bind("newFlags", () => Effect.getRuntimeFlags),
+      // Calculate rollback patch
+      Effect.let("rollbackRefs", ({ newRefs, oldRefs }) => FiberRefsPatch.diff(newRefs, oldRefs)),
+      Effect.let("rollbackFlags", ({ newFlags, oldFlags }) => RuntimeFlags.diff(newFlags, oldFlags)),
+      // Apply the rollbacks when the current scope is closed
+      Effect.tap(({ rollbackFlags, rollbackRefs }) =>
+        Effect.addFinalizer(() =>
+          Effect.zipRight(Effect.patchFiberRefs(rollbackRefs), Effect.patchRuntimeFlags(rollbackFlags))
         )
+      ),
+      // Provide the runtime's context
+      Effect.map(() => runtime.context)
     )
   )
 }

package/src/internal/requestIdleCallback.ts

@@ -3,17 +3,16 @@ export const requestIdleCallback = globalThis.requestIdleCallback || requestIdle
 export const cancelIdleCallback = globalThis.cancelIdleCallback || clearTimeout
 
 function requestIdleCallbackFallbackToSetTimeout(cb: IdleRequestCallback, options?: IdleRequestOptions) {
-  return setTimeout(() => cb(makeIdleDeadline(Date.now(), options)))
+  return setTimeout(() => cb(makeIdleDeadline(Date.now(), options?.timeout)), 0)
 }
 
-function makeIdleDeadline(start: number, options?: IdleRequestOptions) {
-  const timeout = options?.timeout ?? 50
-
-  const timeRemaining = () => Math.max(0, timeout - (Date.now() - start))
+function makeIdleDeadline(start: number, timeout?: number) {
+  const end = timeout === undefined ? Infinity : start + timeout
+  const timeRemaining = () => Math.max(0, 50 - (Date.now() - start))
 
   return {
     get didTimeout() {
-      return timeRemaining() < 0
+      return Date.now() >= end
     },
     timeRemaining
   }