@clayroach/effect 3.19.14-source-capture.6 → 3.19.14-source-capture.8

package/src/internal/stm/tSet.ts

@@ -1,259 +0,0 @@
-import * as RA from "../../Array.js"
-import * as Chunk from "../../Chunk.js"
-import { dual, pipe } from "../../Function.js"
-import * as HashSet from "../../HashSet.js"
-import type * as Option from "../../Option.js"
-import { hasProperty, type Predicate } from "../../Predicate.js"
-import * as STM from "../../STM.js"
-import type * as TMap from "../../TMap.js"
-import type * as TSet from "../../TSet.js"
-import * as core from "./core.js"
-import * as tMap from "./tMap.js"
-
-/** @internal */
-const TSetSymbolKey = "effect/TSet"
-
-/** @internal */
-export const TSetTypeId: TSet.TSetTypeId = Symbol.for(
-  TSetSymbolKey
-) as TSet.TSetTypeId
-
-const tSetVariance = {
-  /* c8 ignore next */
-  _A: (_: any) => _
-}
-
-/** @internal */
-class TSetImpl<in out A> implements TSet.TSet<A> {
-  readonly [TSetTypeId] = tSetVariance
-  constructor(readonly tMap: TMap.TMap<A, void>) {}
-}
-
-const isTSet = (u: unknown) => hasProperty(u, TSetTypeId)
-
-/** @internal */
-export const add = dual<
-  <A>(value: A) => (self: TSet.TSet<A>) => STM.STM<void>,
-  <A>(self: TSet.TSet<A>, value: A) => STM.STM<void>
->(2, (self, value) => tMap.set(self.tMap, value, void 0 as void))
-
-/** @internal */
-export const difference = dual<
-  <A>(other: TSet.TSet<A>) => (self: TSet.TSet<A>) => STM.STM<void>,
-  <A>(self: TSet.TSet<A>, other: TSet.TSet<A>) => STM.STM<void>
->(2, (self, other) =>
-  core.flatMap(
-    toHashSet(other),
-    (values) => removeIf(self, (value) => HashSet.has(values, value), { discard: true })
-  ))
-
-/** @internal */
-export const empty = <A>(): STM.STM<TSet.TSet<A>> => fromIterable<A>([])
-
-/** @internal */
-export const forEach = dual<
-  <A, R, E>(f: (value: A) => STM.STM<void, E, R>) => (self: TSet.TSet<A>) => STM.STM<void, E, R>,
-  <A, R, E>(self: TSet.TSet<A>, f: (value: A) => STM.STM<void, E, R>) => STM.STM<void, E, R>
->(2, (self, f) => reduceSTM(self, void 0 as void, (_, value) => f(value)))
-
-/** @internal */
-export const fromIterable = <A>(iterable: Iterable<A>): STM.STM<TSet.TSet<A>> =>
-  core.map(
-    tMap.fromIterable(Array.from(iterable).map((a): [A, void] => [a, void 0])),
-    (tMap) => new TSetImpl(tMap)
-  )
-
-/** @internal */
-export const has = dual<
-  <A>(value: A) => (self: TSet.TSet<A>) => STM.STM<boolean>,
-  <A>(self: TSet.TSet<A>, value: A) => STM.STM<boolean>
->(2, (self, value) => tMap.has(self.tMap, value))
-
-/** @internal */
-export const intersection = dual<
-  <A>(other: TSet.TSet<A>) => (self: TSet.TSet<A>) => STM.STM<void>,
-  <A>(self: TSet.TSet<A>, other: TSet.TSet<A>) => STM.STM<void>
->(2, (self, other) =>
-  core.flatMap(
-    toHashSet(other),
-    (values) => pipe(self, retainIf((value) => pipe(values, HashSet.has(value)), { discard: true }))
-  ))
-
-/** @internal */
-export const isEmpty = <A>(self: TSet.TSet<A>): STM.STM<boolean> => tMap.isEmpty(self.tMap)
-
-/** @internal */
-export const make = <Elements extends Array<any>>(
-  ...elements: Elements
-): STM.STM<TSet.TSet<Elements[number]>> => fromIterable(elements)
-
-/** @internal */
-export const reduce = dual<
-  <Z, A>(zero: Z, f: (accumulator: Z, value: A) => Z) => (self: TSet.TSet<A>) => STM.STM<Z>,
-  <Z, A>(self: TSet.TSet<A>, zero: Z, f: (accumulator: Z, value: A) => Z) => STM.STM<Z>
->(3, (self, zero, f) =>
-  tMap.reduce(
-    self.tMap,
-    zero,
-    (acc, _, key) => f(acc, key)
-  ))
-
-/** @internal */
-export const reduceSTM = dual<
-  <Z, A, R, E>(zero: Z, f: (accumulator: Z, value: A) => STM.STM<Z, E, R>) => (self: TSet.TSet<A>) => STM.STM<Z, E, R>,
-  <Z, A, R, E>(self: TSet.TSet<A>, zero: Z, f: (accumulator: Z, value: A) => STM.STM<Z, E, R>) => STM.STM<Z, E, R>
->(3, (self, zero, f) =>
-  tMap.reduceSTM(
-    self.tMap,
-    zero,
-    (acc, _, key) => f(acc, key)
-  ))
-
-/** @internal */
-export const remove = dual<
-  <A>(value: A) => (self: TSet.TSet<A>) => STM.STM<void>,
-  <A>(self: TSet.TSet<A>, value: A) => STM.STM<void>
->(2, (self, value) => tMap.remove(self.tMap, value))
-
-/** @internal */
-export const removeAll = dual<
-  <A>(iterable: Iterable<A>) => (self: TSet.TSet<A>) => STM.STM<void>,
-  <A>(self: TSet.TSet<A>, iterable: Iterable<A>) => STM.STM<void>
->(2, (self, iterable) => tMap.removeAll(self.tMap, iterable))
-
-/** @internal */
-export const removeIf: {
-  <A>(predicate: Predicate<A>, options: {
-    readonly discard: true
-  }): (self: TSet.TSet<A>) => STM.STM<void>
-  <A>(
-    predicate: Predicate<A>,
-    options?: {
-      readonly discard: false
-    }
-  ): (self: TSet.TSet<A>) => STM.STM<Array<A>>
-  <A>(self: TSet.TSet<A>, predicate: Predicate<A>, options: {
-    readonly discard: true
-  }): STM.STM<void>
-  <A>(
-    self: TSet.TSet<A>,
-    predicate: Predicate<A>,
-    options?: {
-      readonly discard: false
-    }
-  ): STM.STM<Array<A>>
-} = dual(
-  (args) => isTSet(args[0]),
-  (self, predicate, options) =>
-    options?.discard === true ? tMap.removeIf(self.tMap, (key) => predicate(key), { discard: true }) : pipe(
-      tMap.removeIf(self.tMap, (key) => predicate(key)),
-      core.map(RA.map((entry) => entry[0]))
-    )
-)
-
-/** @internal */
-export const retainIf: {
-  <A>(predicate: Predicate<A>, options: {
-    readonly discard: true
-  }): (self: TSet.TSet<A>) => STM.STM<void>
-  <A>(
-    predicate: Predicate<A>,
-    options?: {
-      readonly discard: false
-    }
-  ): (self: TSet.TSet<A>) => STM.STM<Array<A>>
-  <A>(self: TSet.TSet<A>, predicate: Predicate<A>, options: {
-    readonly discard: true
-  }): STM.STM<void>
-  <A>(
-    self: TSet.TSet<A>,
-    predicate: Predicate<A>,
-    options?: {
-      readonly discard: false
-    }
-  ): STM.STM<Array<A>>
-} = dual((args) => isTSet(args[0]), (self, predicate, options) =>
-  options?.discard === true ?
-    tMap.retainIf(self.tMap, (key) => predicate(key), { discard: true }) :
-    pipe(
-      tMap.retainIf(self.tMap, (key) => predicate(key)),
-      core.map(RA.map((entry) => entry[0]))
-    ))
-
-/** @internal */
-export const size = <A>(self: TSet.TSet<A>): STM.STM<number> => core.map(toChunk(self), (chunk) => chunk.length)
-
-/** @internal */
-export const takeFirst = dual<
-  <A, B>(pf: (a: A) => Option.Option<B>) => (self: TSet.TSet<A>) => STM.STM<B>,
-  <A, B>(self: TSet.TSet<A>, pf: (a: A) => Option.Option<B>) => STM.STM<B>
->(2, (self, pf) => tMap.takeFirst(self.tMap, (key) => pf(key)))
-
-/** @internal */
-export const takeFirstSTM = dual<
-  <A, B, E, R>(pf: (a: A) => STM.STM<B, Option.Option<E>, R>) => (self: TSet.TSet<A>) => STM.STM<B, E, R>,
-  <A, B, E, R>(self: TSet.TSet<A>, pf: (a: A) => STM.STM<B, Option.Option<E>, R>) => STM.STM<B, E, R>
->(2, (self, pf) => tMap.takeFirstSTM(self.tMap, (key) => pf(key)))
-
-/** @internal */
-export const takeSome = dual<
-  <A, B>(pf: (a: A) => Option.Option<B>) => (self: TSet.TSet<A>) => STM.STM<RA.NonEmptyArray<B>>,
-  <A, B>(self: TSet.TSet<A>, pf: (a: A) => Option.Option<B>) => STM.STM<RA.NonEmptyArray<B>>
->(2, (self, pf) => tMap.takeSome(self.tMap, (key) => pf(key)))
-
-/** @internal */
-export const takeSomeSTM = dual<
-  <A, B, E, R>(
-    pf: (a: A) => STM.STM<B, Option.Option<E>, R>
-  ) => (self: TSet.TSet<A>) => STM.STM<RA.NonEmptyArray<B>, E, R>,
-  <A, B, E, R>(
-    self: TSet.TSet<A>,
-    pf: (a: A) => STM.STM<B, Option.Option<E>, R>
-  ) => STM.STM<RA.NonEmptyArray<B>, E, R>
->(2, (self, pf) => tMap.takeSomeSTM(self.tMap, (key) => pf(key)))
-
-/** @internal */
-export const toChunk = <A>(self: TSet.TSet<A>): STM.STM<Chunk.Chunk<A>> =>
-  tMap.keys(self.tMap).pipe(STM.map(Chunk.unsafeFromArray))
-
-/** @internal */
-export const toHashSet = <A>(self: TSet.TSet<A>): STM.STM<HashSet.HashSet<A>> =>
-  reduce(
-    self,
-    HashSet.empty<A>(),
-    (acc, value) => pipe(acc, HashSet.add(value))
-  )
-
-/** @internal */
-export const toArray = <A>(self: TSet.TSet<A>): STM.STM<Array<A>> =>
-  reduce<Array<A>, A>(
-    self,
-    [],
-    (acc, value) => [...acc, value]
-  )
-
-/** @internal */
-export const toReadonlySet = <A>(self: TSet.TSet<A>): STM.STM<ReadonlySet<A>> =>
-  core.map(toArray(self), (values) => new Set(values))
-
-/** @internal */
-export const transform = dual<
-  <A>(f: (a: A) => A) => (self: TSet.TSet<A>) => STM.STM<void>,
-  <A>(self: TSet.TSet<A>, f: (a: A) => A) => STM.STM<void>
->(2, (self, f) => tMap.transform(self.tMap, (key, value) => [f(key), value]))
-
-/** @internal */
-export const transformSTM = dual<
-  <A, R, E>(f: (a: A) => STM.STM<A, E, R>) => (self: TSet.TSet<A>) => STM.STM<void, E, R>,
-  <A, R, E>(self: TSet.TSet<A>, f: (a: A) => STM.STM<A, E, R>) => STM.STM<void, E, R>
->(2, (self, f) =>
-  tMap.transformSTM(
-    self.tMap,
-    (key, value) => core.map(f(key), (a) => [a, value])
-  ))
-
-/** @internal */
-export const union = dual<
-  <A>(other: TSet.TSet<A>) => (self: TSet.TSet<A>) => STM.STM<void>,
-  <A>(self: TSet.TSet<A>, other: TSet.TSet<A>) => STM.STM<void>
->(2, (self, other) => forEach(other, (value) => add(self, value)))

package/src/internal/stm/tSubscriptionRef.ts

@@ -1,286 +0,0 @@
-import * as Effect from "../../Effect.js"
-import { dual, pipe } from "../../Function.js"
-import * as Option from "../../Option.js"
-import { pipeArguments } from "../../Pipeable.js"
-import * as STM from "../../STM.js"
-import * as TPubSub from "../../TPubSub.js"
-import * as TQueue from "../../TQueue.js"
-import * as TRef from "../../TRef.js"
-import type * as TSubscriptionRef from "../../TSubscriptionRef.js"
-import * as stream from "../stream.js"
-import { tDequeueVariance } from "./tQueue.js"
-import { tRefVariance } from "./tRef.js"
-
-/** @internal */
-const TSubscriptionRefSymbolKey = "effect/TSubscriptionRef"
-
-/** @internal */
-export const TSubscriptionRefTypeId: TSubscriptionRef.TSubscriptionRefTypeId = Symbol.for(
-  TSubscriptionRefSymbolKey
-) as TSubscriptionRef.TSubscriptionRefTypeId
-
-const TSubscriptionRefVariance = {
-  /* c8 ignore next */
-  _A: (_: any) => _
-}
-
-class TDequeueMerge<A> implements TQueue.TDequeue<A> {
-  [TQueue.TDequeueTypeId] = tDequeueVariance
-
-  constructor(
-    readonly first: TQueue.TDequeue<A>,
-    readonly second: TQueue.TDequeue<A>
-  ) {}
-
-  peek: STM.STM<A> = STM.gen(this, function*() {
-    const first = yield* this.peekOption
-    if (first._tag === "Some") {
-      return first.value
-    }
-    return yield* STM.retry
-  })
-
-  peekOption: STM.STM<Option.Option<A>> = STM.gen(this, function*() {
-    const first = yield* this.first.peekOption
-    if (first._tag === "Some") {
-      return first
-    }
-    const second = yield* this.second.peekOption
-    if (second._tag === "Some") {
-      return second
-    }
-    return Option.none()
-  })
-
-  take: STM.STM<A> = STM.gen(this, function*() {
-    if (!(yield* this.first.isEmpty)) {
-      return yield* this.first.take
-    }
-    if (!(yield* this.second.isEmpty)) {
-      return yield* this.second.take
-    }
-    return yield* STM.retry
-  })
-
-  takeAll: STM.STM<Array<A>> = STM.gen(this, function*() {
-    return [...yield* this.first.takeAll, ...yield* this.second.takeAll]
-  })
-
-  takeUpTo(max: number): STM.STM<Array<A>> {
-    return STM.gen(this, function*() {
-      const first = yield* this.first.takeUpTo(max)
-      if (first.length >= max) {
-        return first
-      }
-      return [...first, ...yield* this.second.takeUpTo(max - first.length)]
-    })
-  }
-
-  capacity(): number {
-    return this.first.capacity() + this.second.capacity()
-  }
-
-  size: STM.STM<number> = STM.gen(this, function*() {
-    return (yield* this.first.size) + (yield* this.second.size)
-  })
-
-  isFull: STM.STM<boolean> = STM.gen(this, function*() {
-    return (yield* this.first.isFull) && (yield* this.second.isFull)
-  })
-
-  isEmpty: STM.STM<boolean> = STM.gen(this, function*() {
-    return (yield* this.first.isEmpty) && (yield* this.second.isEmpty)
-  })
-
-  shutdown: STM.STM<void> = STM.gen(this, function*() {
-    yield* this.first.shutdown
-    yield* this.second.shutdown
-  })
-
-  isShutdown: STM.STM<boolean> = STM.gen(this, function*() {
-    return (yield* this.first.isShutdown) && (yield* this.second.isShutdown)
-  })
-
-  awaitShutdown: STM.STM<void> = STM.gen(this, function*() {
-    yield* this.first.awaitShutdown
-    yield* this.second.awaitShutdown
-  })
-}
-
-/** @internal */
-class TSubscriptionRefImpl<in out A> implements TSubscriptionRef.TSubscriptionRef<A> {
-  readonly [TSubscriptionRefTypeId] = TSubscriptionRefVariance
-  readonly [TRef.TRefTypeId] = tRefVariance
-
-  constructor(
-    readonly ref: TRef.TRef<A>,
-    readonly pubsub: TPubSub.TPubSub<A>
-  ) {}
-
-  get todos() {
-    return this.ref.todos
-  }
-
-  get versioned() {
-    return this.ref.versioned
-  }
-
-  pipe() {
-    return pipeArguments(this, arguments)
-  }
-
-  get changes(): STM.STM<TQueue.TDequeue<A>> {
-    return STM.gen(this, function*() {
-      const first = yield* TQueue.unbounded<A>()
-      yield* TQueue.offer(first, yield* TRef.get(this.ref))
-      return new TDequeueMerge(first, yield* TPubSub.subscribe(this.pubsub))
-    })
-  }
-
-  modify<B>(f: (a: A) => readonly [B, A]): STM.STM<B> {
-    return pipe(
-      TRef.get(this.ref),
-      STM.map(f),
-      STM.flatMap(([b, a]) =>
-        pipe(
-          TRef.set(this.ref, a),
-          STM.as(b),
-          STM.zipLeft(TPubSub.publish(this.pubsub, a))
-        )
-      )
-    )
-  }
-}
-
-/** @internal */
-export const make = <A>(value: A): STM.STM<TSubscriptionRef.TSubscriptionRef<A>> =>
-  pipe(
-    STM.all([
-      TPubSub.unbounded<A>(),
-      TRef.make(value)
-    ]),
-    STM.map(([pubsub, ref]) => new TSubscriptionRefImpl(ref, pubsub))
-  )
-
-/** @internal */
-export const get = <A>(self: TSubscriptionRef.TSubscriptionRef<A>) => TRef.get(self.ref)
-
-/** @internal */
-export const set = dual<
-  <A>(value: A) => (self: TSubscriptionRef.TSubscriptionRef<A>) => STM.STM<void>,
-  <A>(self: TSubscriptionRef.TSubscriptionRef<A>, value: A) => STM.STM<void>
->(
-  2,
-  <A>(self: TSubscriptionRef.TSubscriptionRef<A>, value: A): STM.STM<void> =>
-    self.modify((): [void, A] => [void 0, value])
-)
-
-/** @internal */
-export const getAndSet = dual<
-  <A>(value: A) => (self: TSubscriptionRef.TSubscriptionRef<A>) => STM.STM<A>,
-  <A>(self: TSubscriptionRef.TSubscriptionRef<A>, value: A) => STM.STM<A>
->(2, (self, value) => self.modify((a) => [a, value]))
-
-/** @internal */
-export const getAndUpdate = dual<
-  <A>(f: (a: A) => A) => (self: TSubscriptionRef.TSubscriptionRef<A>) => STM.STM<A>,
-  <A>(self: TSubscriptionRef.TSubscriptionRef<A>, f: (a: A) => A) => STM.STM<A>
->(2, (self, f) => self.modify((a) => [a, f(a)]))
-
-/** @internal */
-export const getAndUpdateSome = dual<
-  <A>(f: (a: A) => Option.Option<A>) => (self: TSubscriptionRef.TSubscriptionRef<A>) => STM.STM<A>,
-  <A>(self: TSubscriptionRef.TSubscriptionRef<A>, f: (a: A) => Option.Option<A>) => STM.STM<A>
->(2, (self, f) =>
-  self.modify((a) =>
-    Option.match(f(a), {
-      onNone: () => [a, a],
-      onSome: (b) => [a, b]
-    })
-  ))
-
-/** @internal */
-export const setAndGet = dual<
-  <A>(value: A) => (self: TSubscriptionRef.TSubscriptionRef<A>) => STM.STM<A>,
-  <A>(self: TSubscriptionRef.TSubscriptionRef<A>, value: A) => STM.STM<A>
->(2, (self, value) => self.modify(() => [value, value]))
-
-/** @internal */
-export const modify = dual<
-  <A, B>(f: (a: A) => readonly [B, A]) => (self: TSubscriptionRef.TSubscriptionRef<A>) => STM.STM<B>,
-  <A, B>(self: TSubscriptionRef.TSubscriptionRef<A>, f: (a: A) => readonly [B, A]) => STM.STM<B>
->(2, (self, f) => self.modify(f))
-
-/** @internal */
-export const modifySome = dual<
-  <A, B>(
-    fallback: B,
-    f: (a: A) => Option.Option<readonly [B, A]>
-  ) => (self: TSubscriptionRef.TSubscriptionRef<A>) => STM.STM<B>,
-  <A, B>(
-    self: TSubscriptionRef.TSubscriptionRef<A>,
-    fallback: B,
-    f: (a: A) => Option.Option<readonly [B, A]>
-  ) => STM.STM<B>
->(3, (self, fallback, f) =>
-  self.modify((a) =>
-    Option.match(f(a), {
-      onNone: () => [fallback, a],
-      onSome: (b) => b
-    })
-  ))
-
-/** @internal */
-export const update = dual<
-  <A>(f: (a: A) => A) => (self: TSubscriptionRef.TSubscriptionRef<A>) => STM.STM<void>,
-  <A>(self: TSubscriptionRef.TSubscriptionRef<A>, f: (a: A) => A) => STM.STM<void>
->(2, (self, f) => self.modify((a) => [void 0, f(a)]))
-
-/** @internal */
-export const updateAndGet = dual<
-  <A>(f: (a: A) => A) => (self: TSubscriptionRef.TSubscriptionRef<A>) => STM.STM<A>,
-  <A>(self: TSubscriptionRef.TSubscriptionRef<A>, f: (a: A) => A) => STM.STM<A>
->(2, (self, f) =>
-  self.modify((a) => {
-    const b = f(a)
-    return [b, b]
-  }))
-
-/** @internal */
-export const updateSome = dual<
-  <A>(f: (a: A) => Option.Option<A>) => (self: TSubscriptionRef.TSubscriptionRef<A>) => STM.STM<void>,
-  <A>(self: TSubscriptionRef.TSubscriptionRef<A>, f: (a: A) => Option.Option<A>) => STM.STM<void>
->(
-  2,
-  (self, f) =>
-    self.modify((a) => [
-      void 0,
-      Option.match(f(a), {
-        onNone: () => a,
-        onSome: (b) => b
-      })
-    ])
-)
-
-/** @internal */
-export const updateSomeAndGet = dual<
-  <A>(f: (a: A) => Option.Option<A>) => (self: TSubscriptionRef.TSubscriptionRef<A>) => STM.STM<A>,
-  <A>(self: TSubscriptionRef.TSubscriptionRef<A>, f: (a: A) => Option.Option<A>) => STM.STM<A>
->(
-  2,
-  (self, f) =>
-    self.modify((a) =>
-      Option.match(f(a), {
-        onNone: () => [a, a],
-        onSome: (b) => [b, b]
-      })
-    )
-)
-
-/** @internal */
-export const changesScoped = <A>(self: TSubscriptionRef.TSubscriptionRef<A>) =>
-  Effect.acquireRelease(self.changes, TQueue.shutdown)
-
-/** @internal */
-export const changesStream = <A>(self: TSubscriptionRef.TSubscriptionRef<A>) =>
-  stream.unwrap(Effect.map(self.changes, stream.fromTQueue))

package/src/internal/stm/tryCommit.ts

@@ -1,34 +0,0 @@
-import type * as Exit from "../../Exit.js"
-import type * as Journal from "./journal.js"
-import * as OpCodes from "./opCodes/tryCommit.js"
-
-/** @internal */
-export type TryCommit<A, E = never> = Done<A, E> | Suspend
-
-/** @internal */
-export interface Done<out A, out E> {
-  readonly _tag: OpCodes.OP_DONE
-  readonly exit: Exit.Exit<A, E>
-}
-
-/** @internal */
-export interface Suspend {
-  readonly _tag: OpCodes.OP_SUSPEND
-  readonly journal: Journal.Journal
-}
-
-/** @internal */
-export const done = <A, E>(exit: Exit.Exit<A, E>): TryCommit<A, E> => {
-  return {
-    _tag: OpCodes.OP_DONE,
-    exit
-  }
-}
-
-/** @internal */
-export const suspend = (journal: Journal.Journal): TryCommit<never> => {
-  return {
-    _tag: OpCodes.OP_SUSPEND,
-    journal
-  }
-}

package/src/internal/stm/txnId.ts

@@ -1,14 +0,0 @@
-/** @internal */
-export type TxnId = number & {
-  readonly TransactioId: unique symbol
-}
-
-/** @internal */
-const txnCounter = { ref: 0 }
-
-/** @internal */
-export const make = (): TxnId => {
-  const newId = txnCounter.ref + 1
-  txnCounter.ref = newId
-  return newId as TxnId
-}

package/src/internal/stm/versioned.ts

@@ -1,4 +0,0 @@
-/** @internal */
-export class Versioned<out A> {
-  constructor(readonly value: A) {}
-}

package/src/internal/stream/debounceState.ts

@@ -1,57 +0,0 @@
-import type * as Chunk from "../../Chunk.js"
-import type * as Fiber from "../../Fiber.js"
-import type * as HandoffSignal from "./handoffSignal.js"
-
-/** @internal */
-export type DebounceState<A, E = never> = NotStarted | Previous<A> | Current<A, E>
-
-/** @internal */
-export const OP_NOT_STARTED = "NotStarted" as const
-
-/** @internal */
-export type OP_NOT_STARTED = typeof OP_NOT_STARTED
-
-/** @internal */
-export const OP_PREVIOUS = "Previous" as const
-
-/** @internal */
-export type OP_PREVIOUS = typeof OP_PREVIOUS
-
-/** @internal */
-export const OP_CURRENT = "Current" as const
-
-/** @internal */
-export type OP_CURRENT = typeof OP_CURRENT
-
-export interface NotStarted {
-  readonly _tag: OP_NOT_STARTED
-}
-
-/** @internal */
-export interface Previous<out A> {
-  readonly _tag: OP_PREVIOUS
-  readonly fiber: Fiber.Fiber<Chunk.Chunk<A>>
-}
-
-/** @internal */
-export interface Current<out A, out E = never> {
-  readonly _tag: OP_CURRENT
-  readonly fiber: Fiber.Fiber<HandoffSignal.HandoffSignal<A, E>, E>
-}
-
-/** @internal */
-export const notStarted: DebounceState<never> = {
-  _tag: OP_NOT_STARTED
-}
-
-/** @internal */
-export const previous = <A>(fiber: Fiber.Fiber<Chunk.Chunk<A>>): DebounceState<A> => ({
-  _tag: OP_PREVIOUS,
-  fiber
-})
-
-/** @internal */
-export const current = <A, E>(fiber: Fiber.Fiber<HandoffSignal.HandoffSignal<A, E>, E>): DebounceState<A, E> => ({
-  _tag: OP_CURRENT,
-  fiber
-})