@typed/fx 1.17.3 → 1.18.0

package/src/internal/matchers.ts

@@ -0,0 +1,83 @@
+import * as Cause from "effect/Cause"
+import * as Effect from "effect/Effect"
+import * as TypeId from "../TypeId"
+
+import type * as Sink from "../Sink"
+
+import type { Fx, FxInput } from "../Fx"
+import type { RefSubject } from "../RefSubject"
+import type * as Primitive from "./fx-primitive"
+
+export function matchFxPrimitive<B>(
+  matchers: {
+    readonly Empty: <R2>(fx: Primitive.Empty, sink: Sink.WithContext<R2, never, never>) => B
+    readonly Fail: <E, R2>(fx: Primitive.Fail<E>, sink: Sink.WithContext<R2, E, never>) => B
+    readonly FromIterable: <A, R2>(fx: Primitive.FromIterable<A>, sink: Sink.WithContext<R2, never, A>) => B
+    readonly FromSink: <R, E, A, R2>(fx: Primitive.FromSink<R, E, A>, sink: Sink.WithContext<R2, E, A>) => B
+    readonly Never: <R2>(fx: Primitive.Never, sink: Sink.WithContext<R2, never, never>) => B
+    readonly Succeed: <A, R2>(fx: Primitive.Succeed<A>, sink: Sink.WithContext<R2, never, A>) => B
+    readonly Suspend: <R, E, A, R2>(fx: Primitive.Suspend<R, E, A>, sink: Sink.WithContext<R2, E, A>) => B
+    readonly Sync: <A, R2>(fx: Primitive.Sync<A>, sink: Sink.WithContext<R2, never, A>) => B
+    readonly ToFx: <R, E, A, R2>(fx: Primitive.ToFx<R, E, A>, sink: Sink.WithContext<R2, E, A>) => B
+    readonly WithEarlyExit: <R, E, A, R2>(fx: Primitive.WithEarlyExit<R, E, A>, sink: Sink.WithContext<R2, E, A>) => B
+    readonly WithScopedFork: <R, E, A, R2>(
+      fx: Primitive.WithScopedFork<R, E, A>,
+      sink: Sink.WithContext<R2, E, A>
+    ) => B
+    readonly WithFlattenStrategy: <R, E, A, R2>(
+      fx: Primitive.WithFlattenStrategy<R, E, A>,
+      sink: Sink.WithContext<R2, E, A>
+    ) => B
+    readonly Transformer: <R, E, A, R2>(fx: Primitive.Transformer<R, E, A>, sink: Sink.WithContext<R2, E, A>) => B
+    readonly TransformerEffect: <R, E, A, R2>(
+      fx: Primitive.TransformerEffect<R, E, A>,
+      sink: Sink.WithContext<R2, E, A>
+    ) => B
+    readonly TransformerCause: <R, E, A, R2>(
+      fx: Primitive.TransformerCause<R, E, A>,
+      sink: Sink.WithContext<R2, E, A>
+    ) => B
+    readonly TransformerCauseEffect: <R, E, A, R2>(
+      fx: Primitive.TransformerCauseEffect<R, E, A>,
+      sink: Sink.WithContext<R2, E, A>
+    ) => B
+  }
+) {
+  return <R, E, A, R2>(fx: Fx<R, E, A>, sink: Sink.WithContext<R2, E, A>): B => {
+    return (matchers as any)[(fx as Primitive.Primitive)._fxTag](fx as any, sink)
+  }
+}
+
+export function matchFxInput<R, E, A, B>(fx: FxInput<R, E, A>, matchers: {
+  RefSubject: (fx: RefSubject<R, E, A>) => B
+  Fx: (fx: Fx<R, E, A>) => B
+  Effect: (effect: Effect.Effect<R, E, A>) => B
+  Cause: (cause: Cause.Cause<E>) => B
+  Iterable: (iterable: Iterable<A>) => B
+  Otherwise: (value: A) => B
+}): B {
+  const type = typeof fx
+  if (!fx || !(type === "object" || type === "function")) return matchers.Otherwise(fx as A)
+  else if (isRefSubject(fx)) return matchers.RefSubject(fx)
+  else if (isFx(fx)) return matchers.Fx(fx)
+  else if (isEffect(fx)) return matchers.Effect(fx)
+  else if (isCause(fx)) return matchers.Cause(fx)
+  else if (Symbol.iterator in fx) return matchers.Iterable(fx)
+  else return matchers.Otherwise(fx as A)
+}
+
+function isFx<R, E, A>(input: FxInput<R, E, A>): input is Fx<R, E, A> {
+  return TypeId.TypeId in input
+}
+
+function isRefSubject<R, E, A>(input: FxInput<R, E, A>): input is RefSubject<R, E, A> {
+  return TypeId.RefSubjectTypeId in input
+}
+
+function isEffect<R, E, A>(input: FxInput<R, E, A>): input is Effect.Effect<R, E, A> {
+  return Effect.EffectTypeId in input
+}
+
+function isCause<R, E, A>(input: FxInput<R, E, A>): input is Cause.Cause<E> {
+  return Cause.CauseTypeId in input
+}

package/src/internal/protos.ts

@@ -0,0 +1,132 @@
+import * as Effect from "effect/Effect"
+import * as Equal from "effect/Equal"
+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"
+import { TypeId } from "../TypeId"
+
+export const Variance: Fx<any, any, any>[TypeId] = {
+  _R: identity,
+  _E: identity,
+  _A: identity
+}
+
+export abstract class BaseProto implements Equal.Equal, Hash.Hash, Inspectable {
+  [Equal.symbol](that: unknown) {
+    return this === that
+  }
+
+  [Hash.symbol]() {
+    return Hash.random(this)
+  }
+
+  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 class OnceEffect<R, E, A> extends Effectable.Class<R, E, A> {
+  #fiber: Fiber.Fiber<E, A> | undefined
+
+  constructor(
+    readonly effect: Effect.Effect<R, E, A>
+  ) {
+    super()
+  }
+
+  commit() {
+    if (this.#fiber) {
+      return Fiber.join(this.#fiber)
+    } else {
+      return Effect.forkDaemon(this.effect).pipe(
+        Effect.tap((fiber) => Effect.sync(() => this.#fiber = fiber)),
+        Effect.flatMap(Fiber.join)
+      )
+    }
+  }
+}
+
+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>
+{
+  _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()
+  }
+
+  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())
+  }
+}

package/src/internal/provide.ts

@@ -0,0 +1,143 @@
+import type * as Context from "@typed/context"
+import { Effect, FiberRefsPatch, Layer, Runtime, RuntimeFlags } from "effect"
+
+export type Provide<R, E, A> =
+  | ProvideContext<A>
+  | ProvideLayer<R, E, A>
+  | ProvideRuntime<A>
+  | ProvideService<A, any>
+  | ProvideServiceEffect<R, E, A, any>
+
+export interface ProvideContext<A> {
+  readonly _tag: "ProvideContext"
+  readonly i0: Context.Context<A>
+}
+
+export const ProvideContext = <A>(i0: Context.Context<A>): ProvideContext<A> => ({
+  _tag: "ProvideContext",
+  i0
+})
+
+export interface ProvideLayer<R, E, A> {
+  readonly _tag: "ProvideLayer"
+  readonly i0: Layer.Layer<R, E, A>
+}
+
+export const ProvideLayer = <R, E, A>(i0: Layer.Layer<R, E, A>): ProvideLayer<R, E, A> => ({
+  _tag: "ProvideLayer",
+  i0
+})
+
+export interface ProvideService<I, S> {
+  readonly _tag: "ProvideService"
+  readonly i0: Context.Tag<I, S>
+  readonly i1: S
+}
+
+export const ProvideService = <I, S>(i0: Context.Tag<I, S>, i1: S): ProvideService<I, S> => ({
+  _tag: "ProvideService",
+  i0,
+  i1
+})
+
+export interface ProvideServiceEffect<R, E, I, S> {
+  readonly _tag: "ProvideServiceEffect"
+  readonly i0: Context.Tag<I, S>
+  readonly i1: Effect.Effect<R, E, S>
+}
+
+export const ProvideServiceEffect = <R, E, I, S>(
+  i0: Context.Tag<I, S>,
+  i1: Effect.Effect<R, E, S>
+): ProvideServiceEffect<R, E, I, S> => ({
+  _tag: "ProvideServiceEffect",
+  i0,
+  i1
+})
+
+export interface ProvideRuntime<A> {
+  readonly _tag: "ProvideRuntime"
+  readonly i0: Runtime.Runtime<A>
+}
+
+export const ProvideRuntime = <A>(i0: Runtime.Runtime<A>): ProvideRuntime<A> => ({
+  _tag: "ProvideRuntime",
+  i0
+})
+
+export function matchProvide<R = never, E = never, A = never, B = never>(
+  self: Provide<R, E, A>,
+  matchers: {
+    readonly ProvideContext: (i0: Context.Context<A>) => B
+    readonly ProvideRuntime: (i0: Runtime.Runtime<A>) => B
+    readonly ProvideLayer: (i0: Layer.Layer<R, E, A>) => B
+    readonly ProvideService: (tag: Context.Tag<A, any>, service: any) => B
+    readonly ProvideServiceEffect: (tag: Context.Tag<A, any>, service: Effect.Effect<R, E, any>) => B
+  }
+): B {
+  return matchers[self._tag](self.i0 as any, (self as any).i1)
+}
+
+export function merge<R = never, E = never, A = never, R2 = never, E2 = never, B = never>(
+  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)
+  })
+}
+
+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.succeedContext(ctx), layer)),
+    ProvideLayer: (layerB) => ProvideLayer(Layer.provideMerge(layerB, layer)),
+    ProvideRuntime: (runtime) => ProvideLayer(Layer.provideMerge(runtimeToLayer(runtime), layer)),
+    ProvideService: (tag, service) => ProvideLayer(Layer.provideMerge(Layer.succeed(tag, service), layer)),
+    ProvideServiceEffect: (tag, service) => ProvideLayer(Layer.provideMerge(Layer.effect(tag, service), layer))
+  })
+}
+
+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> {
+  switch (provide._tag) {
+    case "ProvideContext":
+    case "ProvideLayer":
+    case "ProvideRuntime":
+      return Effect.provide(effect, provide.i0 as Layer.Layer<R2, E2, S>)
+    case "ProvideService":
+      return Effect.provideService(effect, provide.i0, provide.i1)
+    case "ProvideServiceEffect":
+      return Effect.provideServiceEffect(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)
+  const patchRefs = FiberRefsPatch.diff(Runtime.defaultRuntime.fiberRefs, runtime.fiberRefs)
+  const inversePatchRefs = FiberRefsPatch.diff(runtime.fiberRefs, Runtime.defaultRuntime.fiberRefs)
+
+  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)
+        )
+    )
+  )
+}

package/src/internal/requestIdleCallback.ts

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

package/src/internal/run.ts

@@ -0,0 +1,51 @@
+import * as Effect from "effect/Effect"
+
+import * as Sink from "../Sink"
+import { compileCauseEffectOperatorSink, compileEffectOperatorSink } from "./effect-operator"
+import * as helpers from "./helpers"
+import { compileSyncOperatorFailureSink, compileSyncOperatorSink } from "./sync-operator"
+
+import type { Fx } from "../Fx"
+import { matchFxPrimitive } from "./matchers"
+
+const constUnit = () => Effect.unit
+
+/**
+ * Run an Fx to completion with the provided Sink.
+ */
+export function run<R, E, A, R2>(
+  fx: Fx<R, E, A>,
+  sink: Sink.WithContext<R2, E, A>
+): Effect.Effect<R | R2, never, unknown> {
+  return runFx(fx, sink)
+}
+
+const runFx = matchFxPrimitive<Effect.Effect<any, never, unknown>>({
+  Empty: constUnit,
+  Fail: (fx, sink) => sink.onFailure(fx.i0),
+  FromIterable: (fx, sink) => Effect.forEach(fx.i0, sink.onSuccess),
+  FromSink: (fx, sink) => Effect.contextWithEffect((ctx) => fx.i0(Sink.provide(sink, ctx))),
+  Never: () => Effect.never,
+  Succeed: (fx, sink) => sink.onSuccess(fx.i0),
+  Suspend: (fx, sink) => Effect.suspend(() => run(fx.i0(), sink)),
+  Sync: (fx, sink) => Effect.suspend(() => sink.onSuccess(fx.i0())),
+  ToFx: ({ fx }, sink) => run(fx, sink),
+  WithEarlyExit: (fx, sink) =>
+    Effect.contextWithEffect((ctx) =>
+      helpers.withScopedFork((fork, scope) =>
+        helpers.withEarlyExit(Sink.provide(sink, ctx), (sink) => fx.i0({ sink, fork, scope }))
+      )
+    ),
+  WithScopedFork: (fx, sink) =>
+    Effect.contextWithEffect((ctx) =>
+      helpers.withScopedFork((fork, scope) => fx.i0({ sink: Sink.provide(sink, ctx), fork, scope }))
+    ),
+  WithFlattenStrategy: (fx, sink) =>
+    Effect.contextWithEffect((ctx) =>
+      helpers.withFlattenStrategy(fx.i1)((fork, scope) => fx.i0({ sink: Sink.provide(sink, ctx), fork, scope }))
+    ),
+  Transformer: (fx, sink) => run(fx.i0, compileSyncOperatorSink(fx.i1, sink)),
+  TransformerEffect: (fx, sink) => run(fx.i0, compileEffectOperatorSink(fx.i1, sink)),
+  TransformerCause: (fx, sink) => run(fx.i0, compileSyncOperatorFailureSink(fx.i1, sink)),
+  TransformerCauseEffect: (fx, sink) => run(fx.i0, compileCauseEffectOperatorSink(fx.i1, sink))
+})

package/src/internal/schema-ref-subject.ts

@@ -0,0 +1,163 @@
+import type { AST } from "@effect/schema"
+import * as SchemaEquivalence from "@effect/schema/Equivalence"
+import * as Schema from "@effect/schema/Schema"
+import { Option } from "effect"
+import * as Effect from "effect/Effect"
+import type * as Equivalence from "effect/Equivalence"
+import type * as Scope from "effect/Scope"
+import type { Fx, FxInput } from "../Fx"
+import type { MakeRefSubject, RefSubject, ToRefSubject } from "../RefSubject"
+import { ComputedTypeId, FilteredTypeId, RefSubjectTypeId } from "../TypeId"
+import { map } from "./core"
+import { make, struct } from "./core-ref-subject"
+import { matchFxInput } from "./matchers"
+
+const makeSchema = <O>(
+  f: <R, E>(
+    input: FxInput<R, E, O>,
+    eq?: Equivalence.Equivalence<O>
+  ) => Effect.Effect<R | Scope.Scope, never, RefSubject<never, E, any> | ToRefSubject<E, O>>
+): MakeRefSubject<O> => f as any as MakeRefSubject<O>
+
+const memoizeThunk = <A>(f: () => A) => {
+  let memoized: Option.Option<A> = Option.none()
+
+  return () => {
+    if (Option.isNone(memoized)) {
+      memoized = Option.some(f()) as Option.Some<A>
+    }
+
+    return memoized.value
+  }
+}
+
+const defaultSchema = <O>(defaultEq?: Equivalence.Equivalence<O>) =>
+  makeSchema(<R, E>(input: FxInput<R, E, O>, eq?: Equivalence.Equivalence<O>) => make(input, eq || defaultEq))
+
+const go = <O>(
+  ast: AST.AST,
+  getDefaultEq: (ast: AST.AST) => Equivalence.Equivalence<O>
+): MakeRefSubject<O> => {
+  switch (ast._tag) {
+    case "AnyKeyword":
+    case "BigIntKeyword":
+    case "BooleanKeyword":
+    case "Literal":
+    case "Enums":
+    case "NeverKeyword":
+    case "NumberKeyword":
+    case "ObjectKeyword":
+    case "StringKeyword":
+    case "SymbolKeyword":
+    case "TemplateLiteral":
+    case "Tuple":
+    case "UndefinedKeyword":
+    case "UniqueSymbol":
+    case "UnknownKeyword":
+    case "VoidKeyword":
+    case "Union": // TODO: Union should probably be better somehow
+      return defaultSchema<O>(getDefaultEq(ast))
+    case "Lazy": {
+      const get = memoizeThunk(() => go<O>(ast.f(), getDefaultEq))
+
+      return makeSchema((input, eq) => get()(input, eq))
+    }
+    case "Refinement":
+      return go(ast.from, getDefaultEq)
+    case "Transform":
+      return go(ast.to, getDefaultEq)
+    case "Declaration":
+      return go(ast.type, getDefaultEq)
+    case "TypeLiteral": {
+      if (ast.propertySignatures.length === 0) {
+        return defaultSchema<O>(getDefaultEq(ast))
+      }
+
+      const propertySignaturesTypes = ast.propertySignatures.map((propertySignature) =>
+        [propertySignature.name, go<any>(propertySignature.type, getDefaultEq)] as const
+      )
+
+      const makeSubjects = <R, E>(inputs: Record<PropertyKey, FxInput<R, E, any>>) =>
+        Effect.gen(function*(_) {
+          const subjects: any = {}
+          for (const [name, make] of propertySignaturesTypes) {
+            subjects[name] = yield* _(make(inputs[name]))
+          }
+
+          return subjects
+        })
+
+      const makeFxInputs = <R, E>(input: Fx<R, E, O>) => {
+        const types: Record<PropertyKey, FxInput<R, E, any>> = {}
+
+        if (RefSubjectTypeId in input || ComputedTypeId in input || FilteredTypeId in input) {
+          for (const [name] of propertySignaturesTypes) {
+            types[name] = (input as RefSubject<R, E, O>).map((o) => o[name as keyof typeof o])
+          }
+        } else {
+          for (const [name] of propertySignaturesTypes) {
+            types[name] = map(input, (o) => o[name as keyof typeof o])
+          }
+        }
+
+        return types
+      }
+
+      const makeEffectInputs = <R, E>(input: Effect.Effect<R, E, O>) => {
+        const types: Record<PropertyKey, FxInput<R, E, any>> = {}
+
+        for (const [name] of propertySignaturesTypes) {
+          types[name] = Effect.map(input, (o) => o[name as keyof typeof o])
+        }
+
+        return types
+      }
+
+      return makeSchema((input, eq) =>
+        matchFxInput(input, {
+          RefSubject: (source) => {
+            return Effect.map(makeSubjects(makeFxInputs(source)), (subjects) => {
+              const ref = rebuild(subjects) as typeof source
+
+              return Object.assign(subjects, {
+                persist: Effect.tap(Effect.matchCauseEffect(ref, source), () =>
+                  "persist" in source ? (source as RefSubject.Derived<any, any, any, any>).persist : Effect.unit)
+              })
+            })
+          }, // TODO: Expand
+          Fx: (fx) =>
+            makeSubjects(makeFxInputs(fx)),
+          Effect: (effect) => makeSubjects(makeEffectInputs(effect)),
+          Cause: (cause) => makeSubjects(makeEffectInputs(Effect.failCause(cause))),
+          // Shouldn't really happen, but just in case fallback to default Schema
+          Iterable: () => defaultSchema<O>()(input, eq),
+          Otherwise: () => defaultSchema<O>()(input, eq)
+        })
+      )
+    }
+  }
+}
+
+export function fromRefSubject<I, O>(source: Schema.Schema<I, O>): MakeRefSubject<I> {
+  return go<I>(Schema.from(source).ast, (ast) => SchemaEquivalence.from(Schema.make(ast)))
+}
+
+export function toRefSubject<I, O>(source: Schema.Schema<I, O>): MakeRefSubject<O> {
+  return go<O>(Schema.to(source).ast, (ast) => SchemaEquivalence.to(Schema.make(ast)))
+}
+
+const rebuild = (subjects: Record<PropertyKey, any>) => {
+  const output: any = {}
+
+  for (const key of Reflect.ownKeys(subjects)) {
+    const value = subjects[key]
+
+    if (RefSubjectTypeId in value) {
+      output[key] = value
+    } else {
+      output[key] = rebuild(value)
+    }
+  }
+
+  return struct(output)
+}

package/src/internal/share.ts

@@ -0,0 +1,105 @@
+import * as Effect from "effect/Effect"
+import * as Fiber from "effect/Fiber"
+import { dual } from "effect/Function"
+import * as MutableRef from "effect/MutableRef"
+import * as Option from "effect/Option"
+import type { Fx } from "../Fx"
+import type { Subject } from "../Subject"
+import { withScopedFork } from "./core"
+import { makeHoldSubject, makeReplaySubject, makeSubject } from "./core-subject"
+import { ToFx } from "./fx-primitive"
+import { run } from "./run"
+
+export function share<R, E, A, R2>(
+  fx: Fx<R, E, A>,
+  subject: Subject<R2, E, A>
+): Fx<R | R2, E, A> {
+  return new Share(fx, subject)
+}
+
+class RefCounter {
+  #refCount: MutableRef.MutableRef<number> = MutableRef.make(0)
+
+  increment() {
+    return MutableRef.updateAndGet(this.#refCount, (n) => n + 1)
+  }
+
+  decrement() {
+    return MutableRef.updateAndGet(this.#refCount, (n) => Math.max(0, n - 1))
+  }
+}
+
+export class Share<R, E, A, R2> extends ToFx<R | R2, E, A> {
+  _FxFiber: MutableRef.MutableRef<Option.Option<Fiber.Fiber<never, unknown>>> = MutableRef.make(Option.none())
+  _RefCount = new RefCounter()
+
+  constructor(
+    readonly i0: Fx<R, E, A>,
+    readonly i1: Subject<R2, E, A>
+  ) {
+    super(i0, i1)
+  }
+
+  toFx(): Fx<R | R2, E, A> {
+    return withScopedFork(({ fork, sink }) =>
+      Effect.flatMap(
+        fork(
+          Effect.onExit(run(this.i1, sink), () => this._RefCount.decrement() === 0 ? this.interrupt() : Effect.unit)
+        ),
+        () => this.initialize()
+      )
+    )
+  }
+
+  private initialize(): Effect.Effect<R | R2, never, unknown> {
+    return Effect.suspend(() => {
+      if (this._RefCount.increment() === 1) {
+        return run(this.i0, this.i1).pipe(
+          Effect.onExit(() => Effect.sync(() => MutableRef.set(this._FxFiber, Option.none()))),
+          Effect.interruptible,
+          Effect.forkDaemon,
+          Effect.tap((fiber) => Effect.sync(() => MutableRef.set(this._FxFiber, Option.some(fiber)))),
+          Effect.flatMap(Fiber.join)
+        )
+      } else {
+        return Option.match(
+          MutableRef.get(this._FxFiber),
+          {
+            onNone: () => Effect.unit,
+            onSome: Fiber.join
+          }
+        )
+      }
+    })
+  }
+
+  private interrupt(): Effect.Effect<R | R2, never, void> {
+    return Effect.suspend(() => {
+      const fiber = Option.getOrNull(MutableRef.getAndSet(this._FxFiber, Option.none()))
+
+      return fiber ? Effect.zip(Fiber.interrupt(fiber), this.i1.interrupt) : this.i1.interrupt
+    })
+  }
+}
+
+export function multicast<R, E, A>(
+  fx: Fx<R, E, A>
+): Fx<R, E, A> {
+  return new Share(fx, makeSubject<E, A>())
+}
+
+export function hold<R, E, A>(
+  fx: Fx<R, E, A>
+): Fx<R, E, A> {
+  return new Share(fx, makeHoldSubject<E, A>())
+}
+
+export const replay: {
+  (capacity: number): <R, E, A>(fx: Fx<R, E, A>) => Fx<R, E, A>
+  <R, E, A>(fx: Fx<R, E, A>, capacity: number): Fx<R, E, A>
+} = dual(2, function replay<R, E, A>(
+  fx: Fx<R, E, A>,
+  capacity: number
+): Fx<R, E, A> {
+  return new Share(fx, makeReplaySubject<E, A>(capacity))
+})