@typed/fx 1.20.2 → 1.20.3

package/src/Fx.ts

@@ -2382,9 +2382,9 @@ export const when: {
 /**
  * @since 1.20.0
  */
-export const withEmitter = <E, A, R = never>(
-  f: (emitter: Emitter.Emitter<E, A>) => Effect.Effect<R, E, unknown>
-): Fx<R | Scope.Scope, E, A> => core.make<R | Scope.Scope, E, A>((sink) => Emitter.withEmitter(sink, f))
+export const withEmitter = <E, A, R = never, E2 = never>(
+  f: (emitter: Emitter.Emitter<E, A>) => Effect.Effect<R, E2, unknown>
+): Fx<R, E | E2, A> => core.make<R, E | E2, A>((sink) => Emitter.withEmitter(sink, f))
 
 /**
  * Create an Fx which will wait a specified duration of time where no

package/src/RefSubject.ts

@@ -1432,7 +1432,7 @@ class RefSubjectTuple<
   ) {
     super()
 
-    this.versioned = Versioned.tuple(refs) as any
+    this.versioned = Versioned.hold(Versioned.tuple(refs)) as any
     this.version = this.versioned.version
     this.interrupt = Effect.all(refs.map((r) => r.interrupt), UNBOUNDED)
     this.subscriberCount = Effect.map(
@@ -1588,7 +1588,7 @@ class RefSubjectStruct<
   ) {
     super()
 
-    this.versioned = Versioned.struct(refs) as any
+    this.versioned = Versioned.hold(Versioned.struct(refs)) as any
     this.version = this.versioned.version
     this.interrupt = Effect.all(Object.values(refs).map((r) => r.interrupt), UNBOUNDED)
     this.subscriberCount = Effect.map(

package/src/Versioned.ts

@@ -255,19 +255,10 @@ export function struct<const VS extends Readonly<Record<string, Versioned<any, a
   Effect.Effect.Error<VS[keyof VS]>,
   { readonly [K in keyof VS]: Effect.Effect.Success<VS[K]> }
 > {
-  return map(
-    tuple(
-      Object.entries(versioneds).map(([k, v]) =>
-        map(v, {
-          onFx: (x) => [k, x] as const,
-          onEffect: (x) => [k, x] as const
-        })
-      )
-    ),
-    {
-      onFx: Object.fromEntries,
-      onEffect: Object.fromEntries
-    }
+  return make(
+    Effect.map(Effect.all(Object.values(versioneds).map((v) => v.version)), (versions) => versions.reduce(sum, 0)),
+    core.struct(versioneds),
+    Effect.all(versioneds, { concurrency: "unbounded" }) as any
   )
 }
 

package/src/internal/helpers.ts

@@ -7,6 +7,7 @@ import * as Effectable from "effect/Effectable"
 import * as Equal from "effect/Equal"
 import * as ExecutionStrategy from "effect/ExecutionStrategy"
 import * as Fiber from "effect/Fiber"
+import * as FiberSet from "effect/FiberSet"
 import * as Option from "effect/Option"
 import * as Ref from "effect/Ref"
 import * as Scope from "effect/Scope"
@@ -225,31 +226,18 @@ export function withExhaustLatestFork<R, E, A>(
 }
 
 export function withUnboundedFork<R, E, A>(
-  f: (fork: FxFork, scope: Scope.Scope) => Effect.Effect<R, E, A>,
-  executionStrategy: ExecutionStrategy.ExecutionStrategy
+  f: (fork: FxFork, scope: Scope.Scope) => Effect.Effect<R, E, A>
 ) {
-  return withScopedFork((fork, scope) =>
+  return Effect.scopeWith((scope) =>
     Effect.flatMap(
-      Ref.make<Map<symbol, Fiber.Fiber<never, void>>>(new Map()),
-      (ref) =>
+      FiberSet.make<never, void>(),
+      (set) =>
         Effect.flatMap(
-          f((effect) => {
-            const id = Symbol()
-
-            return Effect.tap(
-              fork(Effect.onExit(effect, () => Ref.update(ref, (map) => (map.delete(id), map)))),
-              (fiber) => {
-                if (Fiber.isRuntimeFiber(fiber)) {
-                  return Ref.update(ref, (map) => map.set(id, fiber))
-                } else {
-                  return Effect.unit
-                }
-              }
-            )
-          }, scope),
-          () => Effect.flatMap(Ref.get(ref), (fibers) => fibers.size > 0 ? Fiber.joinAll(fibers.values()) : Effect.unit)
+          f((effect) => FiberSet.run(set, effect), scope),
+          () => Fiber.joinAll(set)
         )
-    ), executionStrategy)
+    )
+  )
 }
 
 export function withBoundedFork(capacity: number) {