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

package/src/internal/metric.ts

@@ -1,577 +0,0 @@
-import * as Arr from "../Array.js"
-import * as Clock from "../Clock.js"
-import * as Duration from "../Duration.js"
-import type * as Effect from "../Effect.js"
-import type { LazyArg } from "../Function.js"
-import { constVoid, dual, identity, pipe } from "../Function.js"
-import { globalValue } from "../GlobalValue.js"
-import type * as Metric from "../Metric.js"
-import type * as MetricBoundaries from "../MetricBoundaries.js"
-import type * as MetricHook from "../MetricHook.js"
-import type * as MetricKey from "../MetricKey.js"
-import type * as MetricKeyType from "../MetricKeyType.js"
-import type * as MetricLabel from "../MetricLabel.js"
-import type * as MetricPair from "../MetricPair.js"
-import type * as MetricRegistry from "../MetricRegistry.js"
-import type * as MetricState from "../MetricState.js"
-import { pipeArguments } from "../Pipeable.js"
-import * as Cause from "./cause.js"
-import * as effect_ from "./core-effect.js"
-import * as core from "./core.js"
-import * as metricBoundaries from "./metric/boundaries.js"
-import * as metricKey from "./metric/key.js"
-import * as metricKeyType from "./metric/keyType.js"
-import * as metricLabel from "./metric/label.js"
-import * as metricRegistry from "./metric/registry.js"
-
-/** @internal */
-const MetricSymbolKey = "effect/Metric"
-
-/** @internal */
-export const MetricTypeId: Metric.MetricTypeId = Symbol.for(
-  MetricSymbolKey
-) as Metric.MetricTypeId
-
-const metricVariance = {
-  /* c8 ignore next */
-  _Type: (_: any) => _,
-  /* c8 ignore next */
-  _In: (_: unknown) => _,
-  /* c8 ignore next */
-  _Out: (_: never) => _
-}
-
-/** @internal */
-export const globalMetricRegistry: MetricRegistry.MetricRegistry = globalValue(
-  Symbol.for("effect/Metric/globalMetricRegistry"),
-  () => metricRegistry.make()
-)
-
-/** @internal */
-export const make: Metric.MetricApply = function<Type, In, Out>(
-  keyType: Type,
-  unsafeUpdate: (input: In, extraTags: ReadonlyArray<MetricLabel.MetricLabel>) => void,
-  unsafeValue: (extraTags: ReadonlyArray<MetricLabel.MetricLabel>) => Out,
-  unsafeModify: (input: In, extraTags: ReadonlyArray<MetricLabel.MetricLabel>) => void
-): Metric.Metric<Type, In, Out> {
-  const metric: Metric.Metric<Type, In, Out> = Object.assign(
-    <A extends In, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
-      core.tap(effect, (a) => update(metric, a)),
-    {
-      [MetricTypeId]: metricVariance,
-      keyType,
-      unsafeUpdate,
-      unsafeValue,
-      unsafeModify,
-      register() {
-        this.unsafeValue([])
-        return this as any
-      },
-      pipe() {
-        return pipeArguments(this, arguments)
-      }
-    } as const
-  )
-  return metric
-}
-
-/** @internal */
-export const mapInput = dual<
-  <In, In2>(f: (input: In2) => In) => <Type, Out>(self: Metric.Metric<Type, In, Out>) => Metric.Metric<Type, In2, Out>,
-  <Type, In, Out, In2>(self: Metric.Metric<Type, In, Out>, f: (input: In2) => In) => Metric.Metric<Type, In2, Out>
->(2, (self, f) =>
-  make(
-    self.keyType,
-    (input, extraTags) => self.unsafeUpdate(f(input), extraTags),
-    self.unsafeValue,
-    (input, extraTags) => self.unsafeModify(f(input), extraTags)
-  ))
-
-/** @internal */
-export const counter: {
-  (name: string, options?: {
-    readonly description?: string | undefined
-    readonly bigint?: false | undefined
-    readonly incremental?: boolean | undefined
-  }): Metric.Metric.Counter<number>
-  (name: string, options: {
-    readonly description?: string | undefined
-    readonly bigint: true
-    readonly incremental?: boolean | undefined
-  }): Metric.Metric.Counter<bigint>
-} = (name, options) => fromMetricKey(metricKey.counter(name, options as any)) as any
-
-/** @internal */
-export const frequency = (name: string, options?: {
-  readonly description?: string | undefined
-  readonly preregisteredWords?: ReadonlyArray<string> | undefined
-}): Metric.Metric.Frequency<string> => fromMetricKey(metricKey.frequency(name, options))
-
-/** @internal */
-export const withConstantInput = dual<
-  <In>(input: In) => <Type, Out>(self: Metric.Metric<Type, In, Out>) => Metric.Metric<Type, unknown, Out>,
-  <Type, In, Out>(self: Metric.Metric<Type, In, Out>, input: In) => Metric.Metric<Type, unknown, Out>
->(2, (self, input) => mapInput(self, () => input))
-
-/** @internal */
-export const fromMetricKey = <Type extends MetricKeyType.MetricKeyType<any, any>>(
-  key: MetricKey.MetricKey<Type>
-): Metric.Metric<
-  Type,
-  MetricKeyType.MetricKeyType.InType<Type>,
-  MetricKeyType.MetricKeyType.OutType<Type>
-> => {
-  let untaggedHook:
-    | MetricHook.MetricHook<
-      MetricKeyType.MetricKeyType.InType<Type>,
-      MetricKeyType.MetricKeyType.OutType<Type>
-    >
-    | undefined
-  const hookCache = new WeakMap<ReadonlyArray<MetricLabel.MetricLabel>, MetricHook.MetricHook<any, any>>()
-
-  const hook = (extraTags: ReadonlyArray<MetricLabel.MetricLabel>): MetricHook.MetricHook<
-    MetricKeyType.MetricKeyType.InType<Type>,
-    MetricKeyType.MetricKeyType.OutType<Type>
-  > => {
-    if (extraTags.length === 0) {
-      if (untaggedHook !== undefined) {
-        return untaggedHook
-      }
-      untaggedHook = globalMetricRegistry.get(key)
-      return untaggedHook
-    }
-
-    let hook = hookCache.get(extraTags)
-    if (hook !== undefined) {
-      return hook
-    }
-    hook = globalMetricRegistry.get(metricKey.taggedWithLabels(key, extraTags))
-    hookCache.set(extraTags, hook)
-    return hook
-  }
-
-  return make(
-    key.keyType,
-    (input, extraTags) => hook(extraTags).update(input),
-    (extraTags) => hook(extraTags).get(),
-    (input, extraTags) => hook(extraTags).modify(input)
-  )
-}
-
-/** @internal */
-export const gauge: {
-  (name: string, options?: {
-    readonly description?: string | undefined
-    readonly bigint?: false | undefined
-  }): Metric.Metric.Gauge<number>
-  (name: string, options: {
-    readonly description?: string | undefined
-    readonly bigint: true
-  }): Metric.Metric.Gauge<bigint>
-} = (name, options) => fromMetricKey(metricKey.gauge(name, options as any)) as any
-
-/** @internal */
-export const histogram = (name: string, boundaries: MetricBoundaries.MetricBoundaries, description?: string) =>
-  fromMetricKey(metricKey.histogram(name, boundaries, description))
-
-/* @internal */
-export const increment = (
-  self:
-    | Metric.Metric.Counter<number>
-    | Metric.Metric.Counter<bigint>
-    | Metric.Metric.Gauge<number>
-    | Metric.Metric.Gauge<bigint>
-): Effect.Effect<void> =>
-  metricKeyType.isCounterKey(self.keyType)
-    ? update(self as Metric.Metric.Counter<number>, self.keyType.bigint ? BigInt(1) as any : 1)
-    : modify(self as Metric.Metric.Gauge<number>, self.keyType.bigint ? BigInt(1) as any : 1)
-
-/* @internal */
-export const incrementBy = dual<
-  {
-    (amount: number): (self: Metric.Metric.Counter<number> | Metric.Metric.Counter<number>) => Effect.Effect<void>
-    (amount: bigint): (self: Metric.Metric.Counter<bigint> | Metric.Metric.Gauge<bigint>) => Effect.Effect<void>
-  },
-  {
-    (self: Metric.Metric.Counter<number> | Metric.Metric.Gauge<number>, amount: number): Effect.Effect<void>
-    (self: Metric.Metric.Counter<bigint> | Metric.Metric.Gauge<bigint>, amount: bigint): Effect.Effect<void>
-  }
->(2, (self, amount) =>
-  metricKeyType.isCounterKey(self.keyType)
-    ? update(self as any, amount)
-    : modify(self as any, amount))
-
-/** @internal */
-export const map = dual<
-  <Out, Out2>(f: (out: Out) => Out2) => <Type, In>(self: Metric.Metric<Type, In, Out>) => Metric.Metric<Type, In, Out2>,
-  <Type, In, Out, Out2>(self: Metric.Metric<Type, In, Out>, f: (out: Out) => Out2) => Metric.Metric<Type, In, Out2>
->(2, (self, f) =>
-  make(
-    self.keyType,
-    self.unsafeUpdate,
-    (extraTags) => f(self.unsafeValue(extraTags)),
-    self.unsafeModify
-  ))
-
-/** @internal */
-export const mapType = dual<
-  <Type, Type2>(
-    f: (type: Type) => Type2
-  ) => <In, Out>(
-    self: Metric.Metric<Type, In, Out>
-  ) => Metric.Metric<Type2, In, Out>,
-  <Type, In, Out, Type2>(
-    self: Metric.Metric<Type, In, Out>,
-    f: (type: Type) => Type2
-  ) => Metric.Metric<Type2, In, Out>
->(2, (self, f) =>
-  make(
-    f(self.keyType),
-    self.unsafeUpdate,
-    self.unsafeValue,
-    self.unsafeModify
-  ))
-
-/** @internal */
-export const modify = dual<
-  <In>(input: In) => <Type, Out>(self: Metric.Metric<Type, In, Out>) => Effect.Effect<void>,
-  <Type, In, Out>(self: Metric.Metric<Type, In, Out>, input: In) => Effect.Effect<void>
->(2, (self, input) =>
-  core.fiberRefGetWith(
-    core.currentMetricLabels,
-    (tags) => core.sync(() => self.unsafeModify(input, tags))
-  ))
-
-/* @internal */
-export const set = dual<
-  {
-    (value: number): (self: Metric.Metric.Gauge<number>) => Effect.Effect<void>
-    (value: bigint): (self: Metric.Metric.Gauge<bigint>) => Effect.Effect<void>
-  },
-  {
-    (self: Metric.Metric.Gauge<number>, value: number): Effect.Effect<void>
-    (self: Metric.Metric.Gauge<bigint>, value: bigint): Effect.Effect<void>
-  }
->(2, (self, value) => update(self as any, value))
-
-/** @internal */
-export const succeed = <Out>(out: Out): Metric.Metric<void, unknown, Out> =>
-  make(void 0 as void, constVoid, () => out, constVoid)
-
-/** @internal */
-export const sync = <Out>(evaluate: LazyArg<Out>): Metric.Metric<void, unknown, Out> =>
-  make(void 0 as void, constVoid, evaluate, constVoid)
-
-/** @internal */
-export const summary = (
-  options: {
-    readonly name: string
-    readonly maxAge: Duration.DurationInput
-    readonly maxSize: number
-    readonly error: number
-    readonly quantiles: ReadonlyArray<number>
-    readonly description?: string | undefined
-  }
-): Metric.Metric.Summary<number> => withNow(summaryTimestamp(options))
-
-/** @internal */
-export const summaryTimestamp = (
-  options: {
-    readonly name: string
-    readonly maxAge: Duration.DurationInput
-    readonly maxSize: number
-    readonly error: number
-    readonly quantiles: ReadonlyArray<number>
-    readonly description?: string | undefined
-  }
-): Metric.Metric.Summary<readonly [value: number, timestamp: number]> => fromMetricKey(metricKey.summary(options))
-
-/** @internal */
-export const tagged = dual<
-  <Type, In, Out>(key: string, value: string) => (self: Metric.Metric<Type, In, Out>) => Metric.Metric<Type, In, Out>,
-  <Type, In, Out>(self: Metric.Metric<Type, In, Out>, key: string, value: string) => Metric.Metric<Type, In, Out>
->(3, (self, key, value) => taggedWithLabels(self, [metricLabel.make(key, value)]))
-
-/** @internal */
-export const taggedWithLabelsInput = dual<
-  <In>(
-    f: (input: In) => Iterable<MetricLabel.MetricLabel>
-  ) => <Type, Out>(self: Metric.Metric<Type, In, Out>) => Metric.Metric<Type, In, void>,
-  <Type, In, Out>(
-    self: Metric.Metric<Type, In, Out>,
-    f: (input: In) => Iterable<MetricLabel.MetricLabel>
-  ) => Metric.Metric<Type, In, void>
->(2, (self, f) =>
-  map(
-    make(
-      self.keyType,
-      (input, extraTags) =>
-        self.unsafeUpdate(
-          input,
-          Arr.union(f(input), extraTags)
-        ),
-      self.unsafeValue,
-      (input, extraTags) =>
-        self.unsafeModify(
-          input,
-          Arr.union(f(input), extraTags)
-        )
-    ),
-    constVoid
-  ))
-
-/** @internal */
-export const taggedWithLabels = dual<
-  <Type, In, Out>(
-    extraTags: Iterable<MetricLabel.MetricLabel>
-  ) => (self: Metric.Metric<Type, In, Out>) => Metric.Metric<Type, In, Out>,
-  <Type, In, Out>(
-    self: Metric.Metric<Type, In, Out>,
-    extraTags: Iterable<MetricLabel.MetricLabel>
-  ) => Metric.Metric<Type, In, Out>
->(2, (self, extraTags) => {
-  return make(
-    self.keyType,
-    (input, extraTags1) => self.unsafeUpdate(input, Arr.union(extraTags, extraTags1)),
-    (extraTags1) => self.unsafeValue(Arr.union(extraTags, extraTags1)),
-    (input, extraTags1) => self.unsafeModify(input, Arr.union(extraTags, extraTags1))
-  )
-})
-
-/** @internal */
-export const timer = (name: string, description?: string): Metric.Metric<
-  MetricKeyType.MetricKeyType.Histogram,
-  Duration.Duration,
-  MetricState.MetricState.Histogram
-> => {
-  const boundaries = metricBoundaries.exponential({
-    start: 0.5,
-    factor: 2,
-    count: 35
-  })
-  const base = pipe(histogram(name, boundaries, description), tagged("time_unit", "milliseconds"))
-  return mapInput(base, Duration.toMillis)
-}
-
-/** @internal */
-export const timerWithBoundaries = (
-  name: string,
-  boundaries: ReadonlyArray<number>,
-  description?: string
-): Metric.Metric<
-  MetricKeyType.MetricKeyType.Histogram,
-  Duration.Duration,
-  MetricState.MetricState.Histogram
-> => {
-  const base = pipe(
-    histogram(name, metricBoundaries.fromIterable(boundaries), description),
-    tagged("time_unit", "milliseconds")
-  )
-  return mapInput(base, Duration.toMillis)
-}
-
-/* @internal */
-export const trackAll = dual<
-  <In>(
-    input: In
-  ) => <Type, Out>(
-    self: Metric.Metric<Type, In, Out>
-  ) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
-  <Type, In, Out>(
-    self: Metric.Metric<Type, In, Out>,
-    input: In
-  ) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
->(2, (self, input) => (effect) =>
-  core.matchCauseEffect(effect, {
-    onFailure: (cause) => core.zipRight(update(self, input), core.failCause(cause)),
-    onSuccess: (value) => core.zipRight(update(self, input), core.succeed(value))
-  }))
-
-/* @internal */
-export const trackDefect = dual<
-  <Type, Out>(
-    metric: Metric.Metric<Type, unknown, Out>
-  ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
-  <A, E, R, Type, Out>(
-    self: Effect.Effect<A, E, R>,
-    metric: Metric.Metric<Type, unknown, Out>
-  ) => Effect.Effect<A, E, R>
->(2, (self, metric) => trackDefectWith(self, metric, identity))
-
-/* @internal */
-export const trackDefectWith = dual<
-  <Type, In, Out>(
-    metric: Metric.Metric<Type, In, Out>,
-    f: (defect: unknown) => In
-  ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
-  <A, E, R, Type, In, Out>(
-    self: Effect.Effect<A, E, R>,
-    metric: Metric.Metric<Type, In, Out>,
-    f: (defect: unknown) => In
-  ) => Effect.Effect<A, E, R>
->(3, (self, metric, f) => {
-  const updater = (defect: unknown) => update(metric, f(defect))
-  return effect_.tapDefect(self, (cause) => core.forEachSequentialDiscard(Cause.defects(cause), updater))
-})
-
-/* @internal */
-export const trackDuration = dual<
-  <Type, Out>(
-    metric: Metric.Metric<Type, Duration.Duration, Out>
-  ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
-  <A, E, R, Type, Out>(
-    self: Effect.Effect<A, E, R>,
-    metric: Metric.Metric<Type, Duration.Duration, Out>
-  ) => Effect.Effect<A, E, R>
->(2, (self, metric) => trackDurationWith(self, metric, identity))
-
-/* @internal */
-export const trackDurationWith = dual<
-  <Type, In, Out>(
-    metric: Metric.Metric<Type, In, Out>,
-    f: (duration: Duration.Duration) => In
-  ) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
-  <A, E, R, Type, In, Out>(
-    self: Effect.Effect<A, E, R>,
-    metric: Metric.Metric<Type, In, Out>,
-    f: (duration: Duration.Duration) => In
-  ) => Effect.Effect<A, E, R>
->(3, (self, metric, f) =>
-  Clock.clockWith((clock) => {
-    const startTime = clock.unsafeCurrentTimeNanos()
-    return core.tap(self, (_) => {
-      const endTime = clock.unsafeCurrentTimeNanos()
-      const duration = Duration.nanos(endTime - startTime)
-      return update(metric, f(duration))
-    })
-  }))
-
-/* @internal */
-export const trackError = dual<
-  <Type, In, Out>(
-    metric: Metric.Metric<Type, In, Out>
-  ) => <A, E extends In, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
-  <A, E extends In, R, Type, In, Out>(
-    self: Effect.Effect<A, E, R>,
-    metric: Metric.Metric<Type, In, Out>
-  ) => Effect.Effect<A, E, R>
->(2, <A, E extends In, R, Type, In, Out>(
-  self: Effect.Effect<A, E, R>,
-  metric: Metric.Metric<Type, In, Out>
-) => trackErrorWith(self, metric, (a: In) => a))
-
-/* @internal */
-export const trackErrorWith = dual<
-  <Type, In, Out, In2>(
-    metric: Metric.Metric<Type, In, Out>,
-    f: (error: In2) => In
-  ) => <A, E extends In2, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
-  <A, E extends In2, R, Type, In, Out, In2>(
-    self: Effect.Effect<A, E, R>,
-    metric: Metric.Metric<Type, In, Out>,
-    f: (error: In2) => In
-  ) => Effect.Effect<A, E, R>
->(3, <A, E extends In2, R, Type, In, Out, In2>(
-  self: Effect.Effect<A, E, R>,
-  metric: Metric.Metric<Type, In, Out>,
-  f: (error: In2) => In
-) => {
-  const updater = (error: E): Effect.Effect<void> => update(metric, f(error))
-  return effect_.tapError(self, updater)
-})
-
-/* @internal */
-export const trackSuccess = dual<
-  <Type, In, Out>(
-    metric: Metric.Metric<Type, In, Out>
-  ) => <A extends In, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
-  <A extends In, E, R, Type, In, Out>(
-    self: Effect.Effect<A, E, R>,
-    metric: Metric.Metric<Type, In, Out>
-  ) => Effect.Effect<A, E, R>
->(2, <A extends In, E, R, Type, In, Out>(
-  self: Effect.Effect<A, E, R>,
-  metric: Metric.Metric<Type, In, Out>
-) => trackSuccessWith(self, metric, (a: In) => a))
-
-/* @internal */
-export const trackSuccessWith = dual<
-  <Type, In, Out, In2>(
-    metric: Metric.Metric<Type, In, Out>,
-    f: (value: In2) => In
-  ) => <A extends In2, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
-  <A extends In2, E, R, Type, In, Out, In2>(
-    self: Effect.Effect<A, E, R>,
-    metric: Metric.Metric<Type, In, Out>,
-    f: (value: In2) => In
-  ) => Effect.Effect<A, E, R>
->(3, <A extends In2, E, R, Type, In, Out, In2>(
-  self: Effect.Effect<A, E, R>,
-  metric: Metric.Metric<Type, In, Out>,
-  f: (value: In2) => In
-) => {
-  const updater = (value: A): Effect.Effect<void> => update(metric, f(value))
-  return core.tap(self, updater)
-})
-
-/* @internal */
-export const update = dual<
-  <In>(input: In) => <Type, Out>(self: Metric.Metric<Type, In, Out>) => Effect.Effect<void>,
-  <Type, In, Out>(self: Metric.Metric<Type, In, Out>, input: In) => Effect.Effect<void>
->(2, (self, input) =>
-  core.fiberRefGetWith(
-    core.currentMetricLabels,
-    (tags) => core.sync(() => self.unsafeUpdate(input, tags))
-  ))
-
-/* @internal */
-export const value = <Type, In, Out>(
-  self: Metric.Metric<Type, In, Out>
-): Effect.Effect<Out> =>
-  core.fiberRefGetWith(
-    core.currentMetricLabels,
-    (tags) => core.sync(() => self.unsafeValue(tags))
-  )
-
-/** @internal */
-export const withNow = <Type, In, Out>(
-  self: Metric.Metric<Type, readonly [In, number], Out>
-): Metric.Metric<Type, In, Out> => mapInput(self, (input: In) => [input, Date.now()] as const)
-
-/** @internal */
-export const zip = dual<
-  <Type2, In2, Out2>(
-    that: Metric.Metric<Type2, In2, Out2>
-  ) => <Type, In, Out>(
-    self: Metric.Metric<Type, In, Out>
-  ) => Metric.Metric<readonly [Type, Type2], readonly [In, In2], [Out, Out2]>,
-  <Type, In, Out, Type2, In2, Out2>(
-    self: Metric.Metric<Type, In, Out>,
-    that: Metric.Metric<Type2, In2, Out2>
-  ) => Metric.Metric<readonly [Type, Type2], readonly [In, In2], [Out, Out2]>
->(
-  2,
-  <Type, In, Out, Type2, In2, Out2>(self: Metric.Metric<Type, In, Out>, that: Metric.Metric<Type2, In2, Out2>) =>
-    make(
-      [self.keyType, that.keyType] as const,
-      (input: readonly [In, In2], extraTags) => {
-        const [l, r] = input
-        self.unsafeUpdate(l, extraTags)
-        that.unsafeUpdate(r, extraTags)
-      },
-      (extraTags) => [self.unsafeValue(extraTags), that.unsafeValue(extraTags)],
-      (input: readonly [In, In2], extraTags) => {
-        const [l, r] = input
-        self.unsafeModify(l, extraTags)
-        that.unsafeModify(r, extraTags)
-      }
-    )
-)
-
-/** @internal */
-export const unsafeSnapshot = (): Array<MetricPair.MetricPair.Untyped> => globalMetricRegistry.snapshot()
-
-/** @internal */
-export const snapshot: Effect.Effect<Array<MetricPair.MetricPair.Untyped>> = core.sync(
-  unsafeSnapshot
-)

package/src/internal/opCodes/cause.ts

@@ -1,35 +0,0 @@
-/** @internal */
-export const OP_DIE = "Die" as const
-
-/** @internal */
-export type OP_DIE = typeof OP_DIE
-
-/** @internal */
-export const OP_EMPTY = "Empty" as const
-
-/** @internal */
-export type OP_EMPTY = typeof OP_EMPTY
-
-/** @internal */
-export const OP_FAIL = "Fail" as const
-
-/** @internal */
-export type OP_FAIL = typeof OP_FAIL
-
-/** @internal */
-export const OP_INTERRUPT = "Interrupt" as const
-
-/** @internal */
-export type OP_INTERRUPT = typeof OP_INTERRUPT
-
-/** @internal */
-export const OP_PARALLEL = "Parallel" as const
-
-/** @internal */
-export type OP_PARALLEL = typeof OP_PARALLEL
-
-/** @internal */
-export const OP_SEQUENTIAL = "Sequential" as const
-
-/** @internal */
-export type OP_SEQUENTIAL = typeof OP_SEQUENTIAL

package/src/internal/opCodes/channel.ts

@@ -1,83 +0,0 @@
-/** @internal */
-export const OP_BRACKET_OUT = "BracketOut" as const
-
-/** @internal */
-export type OP_BRACKET_OUT = typeof OP_BRACKET_OUT
-
-/** @internal */
-export const OP_BRIDGE = "Bridge" as const
-
-/** @internal */
-export type OP_BRIDGE = typeof OP_BRIDGE
-
-/** @internal */
-export const OP_CONCAT_ALL = "ConcatAll" as const
-
-/** @internal */
-export type OP_CONCAT_ALL = typeof OP_CONCAT_ALL
-
-/** @internal */
-export const OP_EMIT = "Emit" as const
-
-/** @internal */
-export type OP_EMIT = typeof OP_EMIT
-
-/** @internal */
-export const OP_ENSURING = "Ensuring" as const
-
-/** @internal */
-export type OP_ENSURING = typeof OP_ENSURING
-
-/** @internal */
-export const OP_FAIL = "Fail" as const
-
-/** @internal */
-export type OP_FAIL = typeof OP_FAIL
-
-/** @internal */
-export const OP_FOLD = "Fold" as const
-
-/** @internal */
-export type OP_FOLD = typeof OP_FOLD
-
-/** @internal */
-export const OP_FROM_EFFECT = "FromEffect" as const
-
-/** @internal */
-export type OP_FROM_EFFECT = typeof OP_FROM_EFFECT
-
-/** @internal */
-export const OP_PIPE_TO = "PipeTo" as const
-
-/** @internal */
-export type OP_PIPE_TO = typeof OP_PIPE_TO
-
-/** @internal */
-export const OP_PROVIDE = "Provide" as const
-
-/** @internal */
-export type OP_PROVIDE = typeof OP_PROVIDE
-
-/** @internal */
-export const OP_READ = "Read" as const
-
-/** @internal */
-export type OP_READ = typeof OP_READ
-
-/** @internal */
-export const OP_SUCCEED = "Succeed" as const
-
-/** @internal */
-export type OP_SUCCEED = typeof OP_SUCCEED
-
-/** @internal */
-export const OP_SUCCEED_NOW = "SucceedNow" as const
-
-/** @internal */
-export type OP_SUCCEED_NOW = typeof OP_SUCCEED_NOW
-
-/** @internal */
-export const OP_SUSPEND = "Suspend" as const
-
-/** @internal */
-export type OP_SUSPEND = typeof OP_SUSPEND