effect 3.1.5 → 3.2.0

package/src/Effect.ts

@@ -4130,11 +4130,44 @@ export declare namespace Repeat {
 }
 
 /**
- * Returns a new effect that repeats this effect according to the specified
- * schedule or until the first failure. Scheduled recurrences are in addition
- * to the first execution, so that `io.repeat(Schedule.once)` yields an effect
- * that executes `io`, and then if that succeeds, executes `io` an additional
- * time.
+ * The `repeat` function returns a new effect that repeats the given effect
+ * according to a specified schedule or until the first failure. The scheduled
+ * recurrences are in addition to the initial execution, so `Effect.repeat(action,
+ * Schedule.once)` executes `action` once initially, and if it succeeds, repeats it
+ * an additional time.
+ *
+ * @example
+ * // Success Example
+ * import { Effect, Schedule, Console } from "effect"
+ *
+ * const action = Console.log("success")
+ * const policy = Schedule.addDelay(Schedule.recurs(2), () => "100 millis")
+ * const program = Effect.repeat(action, policy)
+ *
+ * Effect.runPromise(program).then((n) => console.log(`repetitions: ${n}`))
+ *
+ * @example
+ * // Failure Example
+ * import { Effect, Schedule } from "effect"
+ *
+ * let count = 0
+ *
+ * // Define an async effect that simulates an action with possible failures
+ * const action = Effect.async<string, string>((resume) => {
+ *   if (count > 1) {
+ *     console.log("failure")
+ *     resume(Effect.fail("Uh oh!"))
+ *   } else {
+ *     count++
+ *     console.log("success")
+ *     resume(Effect.succeed("yay!"))
+ *   }
+ * })
+ *
+ * const policy = Schedule.addDelay(Schedule.recurs(2), () => "100 millis")
+ * const program = Effect.repeat(action, policy)
+ *
+ * Effect.runPromiseExit(program).then(console.log)
  *
  * @since 2.0.0
  * @category repetition / recursion
@@ -4156,10 +4189,18 @@ export const repeat: {
 } = _schedule.repeat_combined
 
 /**
- * Returns a new effect that repeats this effect the specified number of times
- * or until the first failure. Repeats are in addition to the first execution,
- * so that `io.repeatN(1)` yields an effect that executes `io`, and then if
- * that succeeds, executes `io` an additional time.
+ * The `repeatN` function returns a new effect that repeats the specified effect a
+ * given number of times or until the first failure. The repeats are in addition
+ * to the initial execution, so `Effect.repeatN(action, 1)` executes `action` once
+ * initially and then repeats it one additional time if it succeeds.
+ *
+ * @example
+ * import { Effect, Console } from "effect"
+ *
+ * const action = Console.log("success")
+ * const program = Effect.repeatN(action, 2)
+ *
+ * Effect.runPromise(program)
  *
  * @since 2.0.0
  * @category repetition / recursion
@@ -4170,13 +4211,43 @@ export const repeatN: {
 } = effect.repeatN
 
 /**
- * Returns a new effect that repeats this effect according to the specified
- * schedule or until the first failure, at which point, the failure value and
- * schedule output are passed to the specified handler.
+ * The `repeatOrElse` function returns a new effect that repeats the specified
+ * effect according to the given schedule or until the first failure. When a
+ * failure occurs, the failure value and schedule output are passed to a
+ * specified handler. Scheduled recurrences are in addition to the initial
+ * execution, so `Effect.repeat(action, Schedule.once)` executes `action` once
+ * initially and then repeats it an additional time if it succeeds.
+ *
+ * @example
+ * import { Effect, Schedule } from "effect"
+ *
+ * let count = 0
+ *
+ * // Define an async effect that simulates an action with possible failures
+ * const action = Effect.async<string, string>((resume) => {
+ *   if (count > 1) {
+ *     console.log("failure")
+ *     resume(Effect.fail("Uh oh!"))
+ *   } else {
+ *     count++
+ *     console.log("success")
+ *     resume(Effect.succeed("yay!"))
+ *   }
+ * })
+ *
+ * const policy = Schedule.addDelay(
+ *   Schedule.recurs(2), // Repeat for a maximum of 2 times
+ *   () => "100 millis" // Add a delay of 100 milliseconds between repetitions
+ * )
  *
- * Scheduled recurrences are in addition to the first execution, so that
- * `pipe(effect, Effect.repeat(Schedule.once()))` yields an effect that executes
- * `effect`, and then if that succeeds, executes `effect` an additional time.
+ * const program = Effect.repeatOrElse(action, policy, () =>
+ *   Effect.sync(() => {
+ *     console.log("orElse")
+ *     return count - 1
+ *   })
+ * )
+ *
+ * Effect.runPromise(program).then((n) => console.log(`repetitions: ${n}`))
  *
  * @since 2.0.0
  * @category repetition / recursion
@@ -5364,6 +5435,46 @@ export const withSpan: {
   ): Effect<A, E, Exclude<R, Tracer.ParentSpan>>
 } = effect.withSpan
 
+/**
+ * Wraps a function that returns an effect with a new span for tracing.
+ *
+ * @since 3.2.0
+ * @category models
+ */
+export interface FunctionWithSpanOptions {
+  readonly name: string
+  readonly attributes?: Record<string, unknown> | undefined
+  readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined
+  readonly parent?: Tracer.AnySpan | undefined
+  readonly root?: boolean | undefined
+  readonly context?: Context.Context<never> | undefined
+  readonly kind?: Tracer.SpanKind | undefined
+}
+
+/**
+ * Wraps a function that returns an effect with a new span for tracing.
+ *
+ * @since 3.2.0
+ * @category tracing
+ * @example
+ * import { Effect } from "effect"
+ *
+ * const getTodo = Effect.functionWithSpan({
+ *   body: (id: number) => Effect.succeed(`Got todo ${id}!`),
+ *   options: (id) => ({
+ *     name: `getTodo-${id}`,
+ *     attributes: { id }
+ *   })
+ * })
+ */
+export const functionWithSpan: <Args extends Array<any>, Ret extends Effect<any, any, any>>(
+  options: {
+    readonly body: (...args: Args) => Ret
+    readonly options: FunctionWithSpanOptions | ((...args: Args) => FunctionWithSpanOptions)
+    readonly captureStackTrace?: boolean | undefined
+  }
+) => (...args: Args) => Unify.Unify<Ret> = effect.functionWithSpan
+
 /**
  * Wraps the effect with a new span for tracing.
  *

package/src/Stream.ts

@@ -22,6 +22,7 @@ import type { Pipeable } from "./Pipeable.js"
 import type { Predicate, Refinement } from "./Predicate.js"
 import type * as PubSub from "./PubSub.js"
 import type * as Queue from "./Queue.js"
+import type { Runtime } from "./Runtime.js"
 import type * as Schedule from "./Schedule.js"
 import type * as Scope from "./Scope.js"
 import type * as Sink from "./Sink.js"
@@ -3859,7 +3860,36 @@ export const toQueueOfElements: {
  * @since 2.0.0
  * @category destructors
  */
-export const toReadableStream: <A, E>(source: Stream<A, E>) => ReadableStream<A> = internal.toReadableStream
+export const toReadableStream: <A, E>(self: Stream<A, E>) => ReadableStream<A> = internal.toReadableStream
+
+/**
+ * Converts the stream to a `Effect<ReadableStream>`.
+ *
+ * See https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+export const toReadableStreamEffect: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<ReadableStream<A>, never, R> =
+  internal.toReadableStreamEffect
+
+/**
+ * Converts the stream to a `ReadableStream` using the provided runtime.
+ *
+ * See https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+export const toReadableStreamRuntime: {
+  <XR>(
+    runtime: Runtime<XR>
+  ): <A, E, R extends XR>(self: Stream<A, E, R>) => ReadableStream<A>
+  <A, E, XR, R extends XR>(
+    self: Stream<A, E, R>,
+    runtime: Runtime<XR>
+  ): ReadableStream<A>
+} = internal.toReadableStreamRuntime
 
 /**
  * Applies the transducer to the stream and emits its outputs.

package/src/Tracer.ts

@@ -92,6 +92,7 @@ export interface SpanOptions {
   readonly root?: boolean | undefined
   readonly context?: Context.Context<never> | undefined
   readonly kind?: SpanKind | undefined
+  readonly captureStackTrace?: boolean | string | undefined
 }
 
 /**

package/src/internal/cause.ts

@@ -10,8 +10,8 @@ import * as HashSet from "../HashSet.js"
 import { NodeInspectSymbol, toJSON } from "../Inspectable.js"
 import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
-import { hasProperty, isFunction } from "../Predicate.js"
 import type { Predicate, Refinement } from "../Predicate.js"
+import { hasProperty, isFunction } from "../Predicate.js"
 import type { AnySpan, Span } from "../Tracer.js"
 import type { NoInfer } from "../Types.js"
 import { getBugErrorMessage } from "./errors.js"
@@ -968,53 +968,45 @@ export const reduceWithContext = dual<
 // Pretty Printing
 // -----------------------------------------------------------------------------
 
-const filterStack = (stack: string) => {
-  const lines = stack.split("\n")
-  const out: Array<string> = []
-  for (let i = 0; i < lines.length; i++) {
-    out.push(lines[i].replace(/at .*effect_instruction_i.*\((.*)\)/, "at $1"))
-    if (lines[i].includes("effect_instruction_i")) {
-      return out.join("\n")
-    }
-  }
-  return out.join("\n")
-}
-
 /** @internal */
 export const pretty = <E>(cause: Cause.Cause<E>): string => {
   if (isInterruptedOnly(cause)) {
     return "All fibers interrupted without errors."
   }
-  const final = prettyErrors<E>(cause).map((e) => {
-    let message = e.message
-    if (e.stack) {
-      message += `\r\n${filterStack(e.stack)}`
-    }
-    if (e.span) {
-      let current: Span | AnySpan | undefined = e.span
-      let i = 0
-      while (current && current._tag === "Span" && i < 10) {
-        message += `\r\n    at ${current.name}`
-        current = Option.getOrUndefined(current.parent)
-        i++
+  return prettyErrors<E>(cause).map((e) => e.stack).join("\n")
+}
+
+class PrettyError extends globalThis.Error implements Cause.PrettyError {
+  span: undefined | Span = undefined
+  constructor(originalError: unknown) {
+    const prevLimit = Error.stackTraceLimit
+    Error.stackTraceLimit = 0
+    super(prettyErrorMessage(originalError))
+    Error.stackTraceLimit = prevLimit
+
+    this.name = originalError instanceof Error ? originalError.name : "Error"
+    if (typeof originalError === "object" && originalError !== null) {
+      if (spanSymbol in originalError) {
+        this.span = originalError[spanSymbol] as Span
       }
+      Object.keys(originalError).forEach((key) => {
+        if (!(key in this)) {
+          // @ts-expect-error
+          this[key] = originalError[key]
+        }
+      })
     }
-    return message
-  }).join("\r\n")
-  return final
-}
+    this.stack = prettyErrorStack(
+      this.message,
+      originalError instanceof Error && originalError.stack
+        ? originalError.stack
+        : "",
+      this.span
+    )
+  }
 
-class PrettyError {
-  constructor(
-    readonly message: string,
-    readonly stack: string | undefined,
-    readonly span: Span | undefined
-  ) {}
   toJSON() {
-    const out: any = { message: this.message }
-    if (this.stack) {
-      out.stack = this.stack
-    }
+    const out: any = { message: this.message, stack: this.stack }
     if (this.span) {
       out.span = this.span
     }
@@ -1058,29 +1050,55 @@ export const prettyErrorMessage = (u: unknown): string => {
   return `Error: ${JSON.stringify(u)}`
 }
 
-const spanSymbol = Symbol.for("effect/SpanAnnotation")
+const locationRegex = /\((.*)\)/
+
+const prettyErrorStack = (message: string, stack: string, span?: Span | undefined): string => {
+  const out: Array<string> = [message]
+  const lines = stack.split("\n")
 
-const defaultRenderError = (error: unknown): PrettyError => {
-  const span: any = hasProperty(error, spanSymbol) && error[spanSymbol]
-  if (error instanceof Error) {
-    return new PrettyError(
-      prettyErrorMessage(error),
-      error.stack?.split("\n").filter((_) => _.match(/at (.*)/)).join("\n"),
-      span
+  for (let i = 1; i < lines.length; i++) {
+    if (lines[i].includes("effect_cutpoint") || lines[i].includes("Generator.next")) {
+      break
+    }
+    out.push(
+      lines[i].replace(/at .*effect_instruction_i.*\((.*)\)/, "at $1").replace(/EffectPrimitive\.\w+/, "<anonymous>")
     )
+    if (lines[i].includes("effect_instruction_i")) {
+      break
+    }
   }
-  return new PrettyError(prettyErrorMessage(error), void 0, span)
+
+  if (span) {
+    let current: Span | AnySpan | undefined = span
+    let i = 0
+    while (current && current._tag === "Span" && i < 10) {
+      const stack = current.attributes.get("code.stacktrace")
+      if (typeof stack === "string") {
+        const locationMatch = stack.match(locationRegex)
+        const location = locationMatch ? locationMatch[1] : stack.replace(/^at /, "")
+        out.push(`    at ${current.name} (${location})`)
+      } else {
+        out.push(`    at ${current.name}`)
+      }
+      current = Option.getOrUndefined(current.parent)
+      i++
+    }
+  }
+
+  return out.join("\n")
 }
 
+const spanSymbol = Symbol.for("effect/SpanAnnotation")
+
 /** @internal */
-export const prettyErrors = <E>(cause: Cause.Cause<E>): ReadonlyArray<PrettyError> =>
+export const prettyErrors = <E>(cause: Cause.Cause<E>): Array<PrettyError> =>
   reduceWithContext(cause, void 0, {
-    emptyCase: (): ReadonlyArray<PrettyError> => [],
+    emptyCase: (): Array<PrettyError> => [],
     dieCase: (_, unknownError) => {
-      return [defaultRenderError(unknownError)]
+      return [new PrettyError(unknownError)]
     },
     failCase: (_, error) => {
-      return [defaultRenderError(error)]
+      return [new PrettyError(error)]
     },
     interruptCase: () => [],
     parallelCase: (_, l, r) => [...l, ...r],

package/src/internal/channel.ts

@@ -2310,29 +2310,47 @@ export const updateService = dual<
     )))
 
 /** @internal */
-export const withSpan = dual<
+export const withSpan: {
   (
     name: string,
     options?: Tracer.SpanOptions
-  ) => <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
+  ): <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
     self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-  ) => Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Exclude<Env, Tracer.ParentSpan>>,
+  ) => Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Exclude<Env, Tracer.ParentSpan>>
   <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
     self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
     name: string,
     options?: Tracer.SpanOptions
-  ) => Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Exclude<Env, Tracer.ParentSpan>>
->(3, (self, name, options) =>
-  unwrapScoped(
-    Effect.flatMap(
-      Effect.context(),
-      (context) =>
-        Effect.map(
-          Effect.makeSpanScoped(name, options),
-          (span) => core.provideContext(self, Context.add(context, tracer.spanTag, span))
-        )
+  ): Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Exclude<Env, Tracer.ParentSpan>>
+} = function() {
+  const dataFirst = typeof arguments[0] !== "string"
+  const name = dataFirst ? arguments[1] : arguments[0]
+  const options = tracer.addSpanStackTrace(dataFirst ? arguments[2] : arguments[1])
+  if (dataFirst) {
+    const self = arguments[0]
+    return unwrapScoped(
+      Effect.flatMap(
+        Effect.context(),
+        (context) =>
+          Effect.map(
+            Effect.makeSpanScoped(name, options),
+            (span) => core.provideContext(self, Context.add(context, tracer.spanTag, span))
+          )
+      )
+    )
+  }
+  return (self: Effect.Effect<any, any, any>) =>
+    unwrapScoped(
+      Effect.flatMap(
+        Effect.context(),
+        (context) =>
+          Effect.map(
+            Effect.makeSpanScoped(name, options),
+            (span) => core.provideContext(self, Context.add(context, tracer.spanTag, span))
+          )
+      )
     )
-  ) as any)
+} as any
 
 /** @internal */
 export const writeAll = <OutElem>(

package/src/internal/core-effect.ts

@@ -26,6 +26,7 @@ import * as Ref from "../Ref.js"
 import type * as runtimeFlagsPatch from "../RuntimeFlagsPatch.js"
 import * as Tracer from "../Tracer.js"
 import type { NoInfer } from "../Types.js"
+import type { Unify } from "../Unify.js"
 import { yieldWrapGet } from "../Utils.js"
 import * as internalCause from "./cause.js"
 import { clockTag } from "./clock.js"
@@ -2011,7 +2012,7 @@ const bigint0 = BigInt(0)
 export const unsafeMakeSpan = <XA, XE>(
   fiber: FiberRuntime<XA, XE>,
   name: string,
-  options?: Tracer.SpanOptions
+  options: Tracer.SpanOptions
 ) => {
   const enabled = fiber.getFiberRef(core.currentTracerEnabled)
   if (enabled === false) {
@@ -2029,34 +2030,38 @@ export const unsafeMakeSpan = <XA, XE>(
   const annotationsFromEnv = FiberRefs.get(fiberRefs, core.currentTracerSpanAnnotations)
   const linksFromEnv = FiberRefs.get(fiberRefs, core.currentTracerSpanLinks)
 
-  const parent = options?.parent
+  const parent = options.parent
     ? Option.some(options.parent)
-    : options?.root
+    : options.root
     ? Option.none()
     : Context.getOption(context, internalTracer.spanTag)
 
   const links = linksFromEnv._tag === "Some" ?
-    options?.links !== undefined ?
+    options.links !== undefined ?
       [
         ...Chunk.toReadonlyArray(linksFromEnv.value),
-        ...(options?.links ?? [])
+        ...(options.links ?? [])
       ] :
       Chunk.toReadonlyArray(linksFromEnv.value) :
-    options?.links ?? Arr.empty()
+    options.links ?? Arr.empty()
 
   const span = tracer.span(
     name,
     parent,
-    options?.context ?? Context.empty(),
+    options.context ?? Context.empty(),
     links,
     timingEnabled ? clock.unsafeCurrentTimeNanos() : bigint0,
-    options?.kind ?? "internal"
+    options.kind ?? "internal"
   )
 
+  if (typeof options.captureStackTrace === "string") {
+    span.attribute("code.stacktrace", options.captureStackTrace)
+  }
+
   if (annotationsFromEnv._tag === "Some") {
     HashMap.forEach(annotationsFromEnv.value, (value, key) => span.attribute(key, value))
   }
-  if (options?.attributes !== undefined) {
+  if (options.attributes !== undefined) {
     Object.entries(options.attributes).forEach(([k, v]) => span.attribute(k, v))
   }
 
@@ -2067,7 +2072,10 @@ export const unsafeMakeSpan = <XA, XE>(
 export const makeSpan = (
   name: string,
   options?: Tracer.SpanOptions
-): Effect.Effect<Tracer.Span> => core.withFiberRuntime((fiber) => core.succeed(unsafeMakeSpan(fiber, name, options)))
+): Effect.Effect<Tracer.Span> => {
+  options = internalTracer.addSpanStackTrace(options)
+  return core.withFiberRuntime((fiber) => core.succeed(unsafeMakeSpan(fiber, name, options)))
+}
 
 /* @internal */
 export const spanAnnotations: Effect.Effect<HashMap.HashMap<string, unknown>> = core
@@ -2092,7 +2100,7 @@ export const useSpan: {
     evaluate: (span: Tracer.Span) => Effect.Effect<A, E, R>
   ]
 ) => {
-  const options: Tracer.SpanOptions | undefined = args.length === 1 ? undefined : args[0]
+  const options = internalTracer.addSpanStackTrace(args.length === 1 ? undefined : args[0])
   const evaluate: (span: Tracer.Span) => Effect.Effect<A, E, R> = args[args.length - 1]
 
   return core.withFiberRuntime<A, E, R>((fiber) => {
@@ -2118,25 +2126,66 @@ export const withParentSpan = dual<
 >(2, (self, span) => provideService(self, internalTracer.spanTag, span))
 
 /** @internal */
-export const withSpan = dual<
+export const withSpan: {
   (
     name: string,
-    options?: Tracer.SpanOptions
-  ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, Tracer.ParentSpan>>,
+    options?: Tracer.SpanOptions | undefined
+  ): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, Tracer.ParentSpan>>
   <A, E, R>(
     self: Effect.Effect<A, E, R>,
     name: string,
-    options?: Tracer.SpanOptions
-  ) => Effect.Effect<A, E, Exclude<R, Tracer.ParentSpan>>
->(
-  (args) => typeof args[0] !== "string",
-  (self, name, options) =>
-    useSpan(
-      name,
-      options ?? {},
-      (span) => withParentSpan(self, span)
-    )
-)
+    options?: Tracer.SpanOptions | undefined
+  ): Effect.Effect<A, E, Exclude<R, Tracer.ParentSpan>>
+} = function() {
+  const dataFirst = typeof arguments[0] !== "string"
+  const name = dataFirst ? arguments[1] : arguments[0]
+  const options = internalTracer.addSpanStackTrace(dataFirst ? arguments[2] : arguments[1])
+  if (dataFirst) {
+    const self = arguments[0]
+    return useSpan(name, options, (span) => withParentSpan(self, span))
+  }
+  return (self: Effect.Effect<any, any, any>) => useSpan(name, options, (span) => withParentSpan(self, span))
+} as any
+
+export const functionWithSpan = <Args extends Array<any>, Ret extends Effect.Effect<any, any, any>>(
+  options: {
+    readonly body: (...args: Args) => Ret
+    readonly options: Effect.FunctionWithSpanOptions | ((...args: Args) => Effect.FunctionWithSpanOptions)
+    readonly captureStackTrace?: boolean | undefined
+  }
+): (...args: Args) => Unify<Ret> =>
+  (function(this: any) {
+    let captureStackTrace: string | boolean = options.captureStackTrace ?? false
+    if (options.captureStackTrace !== false) {
+      const limit = Error.stackTraceLimit
+      Error.stackTraceLimit = 2
+      const error = new Error()
+      Error.stackTraceLimit = limit
+      if (error.stack !== undefined) {
+        const stack = error.stack.trim().split("\n")
+        captureStackTrace = stack.slice(2).join("\n").trim()
+      }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const self = this
+    const args = arguments
+    return core.suspend(() => {
+      const opts = typeof options.options === "function"
+        ? options.options.apply(null, arguments as any)
+        : options.options
+
+      return withSpan(
+        core.custom(options.body, function() {
+          return this.effect_instruction_i0.apply(self, args as any)
+        }),
+        opts.name,
+        {
+          ...opts,
+          captureStackTrace
+        }
+      )
+    })
+  }) as any
 
 // -------------------------------------------------------------------------------------
 // optionality

package/src/internal/core.ts

@@ -459,6 +459,10 @@ export const as: {
 /* @internal */
 export const asVoid = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<void, E, R> => as(self, void 0)
 
+function commitCallCutpoint(this: any) {
+  return this.effect_cutpoint()
+}
+
 /* @internal */
 export const custom: {
   <X, A, E, R>(i0: X, body: (this: { effect_instruction_i0: X }) => Effect.Effect<A, E, R>): Effect.Effect<A, E, R>
@@ -477,23 +481,24 @@ export const custom: {
   ): Effect.Effect<A, E, R>
 } = function() {
   const wrapper = new EffectPrimitive(OpCodes.OP_COMMIT) as any
+  wrapper.commit = commitCallCutpoint
   switch (arguments.length) {
     case 2: {
       wrapper.effect_instruction_i0 = arguments[0]
-      wrapper.commit = arguments[1]
+      wrapper.effect_cutpoint = arguments[1]
       break
     }
     case 3: {
       wrapper.effect_instruction_i0 = arguments[0]
       wrapper.effect_instruction_i1 = arguments[1]
-      wrapper.commit = arguments[2]
+      wrapper.effect_cutpoint = arguments[2]
       break
     }
     case 4: {
       wrapper.effect_instruction_i0 = arguments[0]
       wrapper.effect_instruction_i1 = arguments[1]
       wrapper.effect_instruction_i2 = arguments[2]
-      wrapper.commit = arguments[3]
+      wrapper.effect_cutpoint = arguments[3]
       break
     }
     default: {