@clayroach/effect 3.19.14-source-capture.8 → 3.19.14-source-trace.2

package/src/internal/metric.ts

@@ -0,0 +1,577 @@
+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

@@ -0,0 +1,35 @@
+/** @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

@@ -0,0 +1,83 @@
+/** @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