effect 2.4.4 → 2.4.6

package/src/internal/fiberRuntime.ts

@@ -143,7 +143,7 @@ const contOpSuccess = {
     cont: core.OnSuccess,
     value: unknown
   ) => {
-    return cont.i1(value)
+    return cont.effect_instruction_i1(value)
   },
   ["OnStep"]: (
     _: FiberRuntime<any, any>,
@@ -157,7 +157,7 @@ const contOpSuccess = {
     cont: core.OnSuccessAndFailure,
     value: unknown
   ) => {
-    return cont.i2(value)
+    return cont.effect_instruction_i2(value)
   },
   [OpCodes.OP_REVERT_FLAGS]: (
     self: FiberRuntime<any, any>,
@@ -176,10 +176,10 @@ const contOpSuccess = {
     cont: core.While,
     value: unknown
   ) => {
-    cont.i2(value)
-    if (cont.i0()) {
+    cont.effect_instruction_i2(value)
+    if (cont.effect_instruction_i0()) {
       self.pushStack(cont)
-      return cont.i1()
+      return cont.effect_instruction_i1()
     } else {
       return core.unit
     }
@@ -1066,7 +1066,7 @@ export class FiberRuntime<in out A, in out E = never> implements Fiber.RuntimeFi
   }
 
   [OpCodes.OP_SYNC](op: core.Primitive & { _op: OpCodes.OP_SYNC }) {
-    const value = op.i0()
+    const value = op.effect_instruction_i0()
     const cont = this.getNextSuccessCont()
     if (cont !== undefined) {
       if (!(cont._op in contOpSuccess)) {
@@ -1090,7 +1090,7 @@ export class FiberRuntime<in out A, in out E = never> implements Fiber.RuntimeFi
         absurd(cont)
       }
       // @ts-expect-error
-      return contOpSuccess[cont._op](this, cont, oldCur.i0)
+      return contOpSuccess[cont._op](this, cont, oldCur.effect_instruction_i0)
     } else {
       yieldedOpChannel.currentOp = oldCur
       return YieldedOp
@@ -1098,14 +1098,14 @@ export class FiberRuntime<in out A, in out E = never> implements Fiber.RuntimeFi
   }
 
   [OpCodes.OP_FAILURE](op: core.Primitive & { _op: OpCodes.OP_FAILURE }) {
-    const cause = op.i0
+    const cause = op.effect_instruction_i0
     const cont = this.getNextFailCont()
     if (cont !== undefined) {
       switch (cont._op) {
         case OpCodes.OP_ON_FAILURE:
         case OpCodes.OP_ON_SUCCESS_AND_FAILURE: {
           if (!(_runtimeFlags.interruptible(this._runtimeFlags) && this.isInterrupted())) {
-            return cont.i1(cause)
+            return cont.effect_instruction_i1(cause)
           } else {
             return core.exitFailCause(internalCause.stripFailures(cause))
           }
@@ -1136,7 +1136,7 @@ export class FiberRuntime<in out A, in out E = never> implements Fiber.RuntimeFi
   }
 
   [OpCodes.OP_WITH_RUNTIME](op: core.Primitive & { _op: OpCodes.OP_WITH_RUNTIME }) {
-    return op.i0(
+    return op.effect_instruction_i0(
       this as FiberRuntime<unknown, unknown>,
       FiberStatus.running(this._runtimeFlags) as FiberStatus.Running
     )
@@ -1158,7 +1158,7 @@ export class FiberRuntime<in out A, in out E = never> implements Fiber.RuntimeFi
       const patchRefs = FiberRefsPatch.diff(snap.refs, refs)
       const patchFlags = _runtimeFlags.diff(snap.flags, flags)
       return core.exitSucceed(core.blocked(
-        op.i0,
+        op.effect_instruction_i0,
         core.withFiberRuntime<unknown, unknown>((newFiber) => {
           while (frames.length > 0) {
             newFiber.pushStack(frames.pop()!)
@@ -1167,24 +1167,24 @@ export class FiberRuntime<in out A, in out E = never> implements Fiber.RuntimeFi
             FiberRefsPatch.patch(newFiber.id(), newFiber.getFiberRefs())(patchRefs)
           )
           newFiber._runtimeFlags = _runtimeFlags.patch(patchFlags)(newFiber._runtimeFlags)
-          return op.i1
+          return op.effect_instruction_i1
         })
       ))
     }
     return core.uninterruptibleMask((restore) =>
       core.flatMap(
-        forkDaemon(core.runRequestBlock(op.i0)),
-        () => restore(op.i1)
+        forkDaemon(core.runRequestBlock(op.effect_instruction_i0)),
+        () => restore(op.effect_instruction_i1)
       )
     )
   }
 
   ["RunBlocked"](op: core.Primitive & { _op: "RunBlocked" }) {
-    return runBlockedRequests(op.i0)
+    return runBlockedRequests(op.effect_instruction_i0)
   }
 
   [OpCodes.OP_UPDATE_RUNTIME_FLAGS](op: core.Primitive & { _op: OpCodes.OP_UPDATE_RUNTIME_FLAGS }) {
-    const updateFlags = op.i0
+    const updateFlags = op.effect_instruction_i0
     const oldRuntimeFlags = this._runtimeFlags
     const newRuntimeFlags = _runtimeFlags.patch(oldRuntimeFlags, updateFlags)
     // One more chance to short circuit: if we're immediately going
@@ -1196,11 +1196,11 @@ export class FiberRuntime<in out A, in out E = never> implements Fiber.RuntimeFi
     } else {
       // Impossible to short circuit, so record the changes
       this.patchRuntimeFlags(this._runtimeFlags, updateFlags)
-      if (op.i1) {
+      if (op.effect_instruction_i1) {
         // Since we updated the flags, we need to revert them
         const revertFlags = _runtimeFlags.diff(newRuntimeFlags, oldRuntimeFlags)
         this.pushStack(new core.RevertFlags(revertFlags, op))
-        return op.i1(oldRuntimeFlags)
+        return op.effect_instruction_i1(oldRuntimeFlags)
       } else {
         return core.exitUnit
       }
@@ -1209,27 +1209,27 @@ export class FiberRuntime<in out A, in out E = never> implements Fiber.RuntimeFi
 
   [OpCodes.OP_ON_SUCCESS](op: core.Primitive & { _op: OpCodes.OP_ON_SUCCESS }) {
     this.pushStack(op)
-    return op.i0
+    return op.effect_instruction_i0
   }
 
   ["OnStep"](op: core.Primitive & { _op: "OnStep" }) {
     this.pushStack(op)
-    return op.i0
+    return op.effect_instruction_i0
   }
 
   [OpCodes.OP_ON_FAILURE](op: core.Primitive & { _op: OpCodes.OP_ON_FAILURE }) {
     this.pushStack(op)
-    return op.i0
+    return op.effect_instruction_i0
   }
 
   [OpCodes.OP_ON_SUCCESS_AND_FAILURE](op: core.Primitive & { _op: OpCodes.OP_ON_SUCCESS_AND_FAILURE }) {
     this.pushStack(op)
-    return op.i0
+    return op.effect_instruction_i0
   }
 
   [OpCodes.OP_ASYNC](op: core.Primitive & { _op: OpCodes.OP_ASYNC }) {
-    this._asyncBlockingOn = op.i1
-    this.initiateAsync(this._runtimeFlags, op.i0)
+    this._asyncBlockingOn = op.effect_instruction_i1
+    this.initiateAsync(this._runtimeFlags, op.effect_instruction_i0)
     yieldedOpChannel.currentOp = op
     return YieldedOp
   }
@@ -1241,8 +1241,8 @@ export class FiberRuntime<in out A, in out E = never> implements Fiber.RuntimeFi
   }
 
   [OpCodes.OP_WHILE](op: core.Primitive & { _op: OpCodes.OP_WHILE }) {
-    const check = op.i0
-    const body = op.i1
+    const check = op.effect_instruction_i0
+    const body = op.effect_instruction_i1
     if (check()) {
       this.pushStack(op)
       return body()
@@ -1833,7 +1833,7 @@ export const allSuccesses = <A, E, R>(
 ): Effect.Effect<Array<A>, never, R> =>
   core.map(
     all(RA.fromIterable(elements).map(core.exit), options),
-    RA.filterMap((exit) => core.exitIsSuccess(exit) ? Option.some(exit.i0) : Option.none())
+    RA.filterMap((exit) => core.exitIsSuccess(exit) ? Option.some(exit.effect_instruction_i0) : Option.none())
   )
 
 /* @internal */
@@ -2099,7 +2099,7 @@ export const forEachConcurrentDiscard = <A, X, E, R>(
                   if (wrapped._op === "Failure") {
                     exit = wrapped
                   } else {
-                    exit = wrapped.i0 as any
+                    exit = wrapped.effect_instruction_i0 as any
                   }
                   joinOrder.push(fiber)
                   fibers.delete(fiber)
@@ -2110,7 +2110,7 @@ export const forEachConcurrentDiscard = <A, X, E, R>(
                       () => core.exitUnit
                     )))
                   } else if (residual.length + results.length === target) {
-                    const requests = residual.map((blocked) => blocked.i0).reduce(_RequestBlock.par)
+                    const requests = residual.map((blocked) => blocked.effect_instruction_i0).reduce(_RequestBlock.par)
                     resume(core.succeed(core.blocked(
                       requests,
                       forEachConcurrentDiscard(
@@ -2119,7 +2119,7 @@ export const forEachConcurrentDiscard = <A, X, E, R>(
                             core.exitCollectAll(collectExits(), { parallel: true }),
                             () => core.exitUnit
                           ),
-                          ...residual.map((blocked) => blocked.i1)
+                          ...residual.map((blocked) => blocked.effect_instruction_i1)
                         ],
                         (i) => i,
                         batching,

package/src/internal/layer.ts

@@ -232,9 +232,9 @@ class MemoMapImpl implements Layer.MemoMap {
                               switch (exit._tag) {
                                 case EffectOpCodes.OP_FAILURE: {
                                   return pipe(
-                                    core.deferredFailCause(deferred, exit.i0),
+                                    core.deferredFailCause(deferred, exit.effect_instruction_i0),
                                     core.zipRight(core.scopeClose(innerScope, exit)),
-                                    core.zipRight(core.failCause(exit.i0))
+                                    core.zipRight(core.failCause(exit.effect_instruction_i0))
                                   )
                                 }
                                 case EffectOpCodes.OP_SUCCESS: {
@@ -256,8 +256,8 @@ class MemoMapImpl implements Layer.MemoMap {
                                           core.flatMap((finalizer) => finalizer(exit))
                                         ))
                                     ),
-                                    core.zipRight(core.deferredSucceed(deferred, exit.i0)),
-                                    core.as(exit.i0[1])
+                                    core.zipRight(core.deferredSucceed(deferred, exit.effect_instruction_i0)),
+                                    core.as(exit.effect_instruction_i0[1])
                                   )
                                 }
                               }

package/src/internal/runtime.ts

@@ -22,7 +22,6 @@ import * as core from "./core.js"
 import * as executionStrategy from "./executionStrategy.js"
 import * as FiberRuntime from "./fiberRuntime.js"
 import * as fiberScope from "./fiberScope.js"
-import { internalize } from "./internalize.js"
 import * as OpCodes from "./opCodes/effect.js"
 import * as runtimeFlags from "./runtimeFlags.js"
 import * as _supervisor from "./supervisor.js"
@@ -126,9 +125,9 @@ export const unsafeRunCallback = <R>(runtime: Runtime.Runtime<R>) =>
 export const unsafeRunSync = <R>(runtime: Runtime.Runtime<R>) => <A, E>(effect: Effect.Effect<A, E, R>): A => {
   const result = unsafeRunSyncExit(runtime)(effect)
   if (result._tag === "Failure") {
-    throw fiberFailure(result.i0)
+    throw fiberFailure(result.effect_instruction_i0)
   } else {
-    return result.i0
+    return result.effect_instruction_i0
   }
 }
 
@@ -267,10 +266,10 @@ export const unsafeRunPromise = <R>(runtime: Runtime.Runtime<R>) =>
   unsafeRunPromiseExit(runtime)(effect, options).then((result) => {
     switch (result._tag) {
       case OpCodes.OP_SUCCESS: {
-        return result.i0
+        return result.effect_instruction_i0
       }
       case OpCodes.OP_FAILURE: {
-        throw fiberFailure(result.i0)
+        throw fiberFailure(result.effect_instruction_i0)
       }
     }
   })
@@ -477,7 +476,6 @@ export const asyncEffect = <A, E, R, R3, E2, R2>(
   ) => Effect.Effect<Effect.Effect<void, never, R3> | void, E2, R2>
 ): Effect.Effect<A, E | E2, R | R2 | R3> =>
   core.suspend(() => {
-    internalize(register)
     let cleanup: Effect.Effect<void, never, R3> | void = undefined
     return core.flatMap(
       core.deferredMake<A, E | E2>(),

package/src/internal/stm/core.ts

@@ -54,13 +54,13 @@ export type Primitive =
 /** @internal */
 type Op<Tag extends string, Body = {}> = STM.STM<never> & Body & {
   readonly _tag: OP_COMMIT
-  readonly i0: Tag
+  readonly effect_instruction_i0: Tag
 }
 
 /** @internal */
 interface STMEffect extends
   Op<OpCodes.OP_WITH_STM_RUNTIME, {
-    readonly i1: (
+    readonly effect_instruction_i1: (
       runtime: STMDriver<unknown, unknown, unknown>
     ) => STM.STM<unknown, unknown, unknown>
   }>
@@ -69,46 +69,46 @@ interface STMEffect extends
 /** @internal */
 interface STMOnFailure extends
   Op<OpCodes.OP_ON_FAILURE, {
-    readonly i1: STM.STM<unknown, unknown, unknown>
-    readonly i2: (error: unknown) => STM.STM<unknown, unknown, unknown>
+    readonly effect_instruction_i1: STM.STM<unknown, unknown, unknown>
+    readonly effect_instruction_i2: (error: unknown) => STM.STM<unknown, unknown, unknown>
   }>
 {}
 
 /** @internal */
 interface STMOnRetry extends
   Op<OpCodes.OP_ON_RETRY, {
-    readonly i1: STM.STM<unknown, unknown, unknown>
-    readonly i2: () => STM.STM<unknown, unknown, unknown>
+    readonly effect_instruction_i1: STM.STM<unknown, unknown, unknown>
+    readonly effect_instruction_i2: () => STM.STM<unknown, unknown, unknown>
   }>
 {}
 
 /** @internal */
 interface STMOnSuccess extends
   Op<OpCodes.OP_ON_SUCCESS, {
-    readonly i1: STM.STM<unknown, unknown, unknown>
-    readonly i2: (a: unknown) => STM.STM<unknown, unknown, unknown>
+    readonly effect_instruction_i1: STM.STM<unknown, unknown, unknown>
+    readonly effect_instruction_i2: (a: unknown) => STM.STM<unknown, unknown, unknown>
   }>
 {}
 
 /** @internal */
 interface STMProvide extends
   Op<OpCodes.OP_PROVIDE, {
-    readonly i1: STM.STM<unknown, unknown, unknown>
-    readonly i2: (context: Context.Context<unknown>) => Context.Context<unknown>
+    readonly effect_instruction_i1: STM.STM<unknown, unknown, unknown>
+    readonly effect_instruction_i2: (context: Context.Context<unknown>) => Context.Context<unknown>
   }>
 {}
 
 /** @internal */
 interface STMSync extends
   Op<OpCodes.OP_SYNC, {
-    readonly i1: () => unknown
+    readonly effect_instruction_i1: () => unknown
   }>
 {}
 
 /** @internal */
 interface STMSucceed extends
   Op<OpCodes.OP_SUCCEED, {
-    readonly i1: unknown
+    readonly effect_instruction_i1: unknown
   }>
 {}
 
@@ -118,21 +118,21 @@ interface STMRetry extends Op<OpCodes.OP_RETRY, {}> {}
 /** @internal */
 interface STMFail extends
   Op<OpCodes.OP_FAIL, {
-    readonly i1: LazyArg<unknown>
+    readonly effect_instruction_i1: LazyArg<unknown>
   }>
 {}
 
 /** @internal */
 interface STMDie extends
   Op<OpCodes.OP_DIE, {
-    readonly i1: LazyArg<unknown>
+    readonly effect_instruction_i1: LazyArg<unknown>
   }>
 {}
 
 /** @internal */
 interface STMInterrupt extends
   Op<OpCodes.OP_INTERRUPT, {
-    readonly i1: FiberId.Runtime
+    readonly effect_instruction_i1: FiberId.Runtime
   }>
 {}
 
@@ -149,8 +149,8 @@ const stmVariance = {
 class STMPrimitive implements STM.STM<any, any, any> {
   public _tag = OP_COMMIT
   public _op = OP_COMMIT
-  public i1: any = undefined
-  public i2: any = undefined;
+  public effect_instruction_i1: any = undefined
+  public effect_instruction_i2: any = undefined;
   [Effect.EffectTypeId]: any;
   [StreamTypeId]: any;
   [SinkTypeId]: any;
@@ -158,7 +158,7 @@ class STMPrimitive implements STM.STM<any, any, any> {
   get [STMTypeId]() {
     return stmVariance
   }
-  constructor(readonly i0: Primitive["i0"]) {
+  constructor(readonly effect_instruction_i0: Primitive["effect_instruction_i0"]) {
     this[Effect.EffectTypeId] = effectVariance
     this[StreamTypeId] = stmVariance
     this[SinkTypeId] = stmVariance
@@ -446,7 +446,7 @@ export class STMDriver<in out R, out E, out A> {
 
   nextSuccess() {
     let current = this.popStack()
-    while (current !== undefined && current.i0 !== OpCodes.OP_ON_SUCCESS) {
+    while (current !== undefined && current.effect_instruction_i0 !== OpCodes.OP_ON_SUCCESS) {
       current = this.popStack()
     }
     return current
@@ -454,7 +454,7 @@ export class STMDriver<in out R, out E, out A> {
 
   nextFailure() {
     let current = this.popStack()
-    while (current !== undefined && current.i0 !== OpCodes.OP_ON_FAILURE) {
+    while (current !== undefined && current.effect_instruction_i0 !== OpCodes.OP_ON_FAILURE) {
       current = this.popStack()
     }
     return current
@@ -462,7 +462,7 @@ export class STMDriver<in out R, out E, out A> {
 
   nextRetry() {
     let current = this.popStack()
-    while (current !== undefined && current.i0 !== OpCodes.OP_ON_RETRY) {
+    while (current !== undefined && current.effect_instruction_i0 !== OpCodes.OP_ON_RETRY) {
       current = this.popStack()
     }
     return current
@@ -497,17 +497,17 @@ export class STMDriver<in out R, out E, out A> {
               break
             }
             case "Commit": {
-              switch (current.i0) {
+              switch (current.effect_instruction_i0) {
                 case OpCodes.OP_DIE: {
-                  exit = TExit.die(current.i1())
+                  exit = TExit.die(current.effect_instruction_i1())
                   break
                 }
                 case OpCodes.OP_FAIL: {
                   const cont = this.nextFailure()
                   if (cont === undefined) {
-                    exit = TExit.fail(current.i1())
+                    exit = TExit.fail(current.effect_instruction_i1())
                   } else {
-                    curr = cont.i2(current.i1()) as Primitive
+                    curr = cont.effect_instruction_i2(current.effect_instruction_i1()) as Primitive
                   }
                   break
                 }
@@ -516,7 +516,7 @@ export class STMDriver<in out R, out E, out A> {
                   if (cont === undefined) {
                     exit = TExit.retry
                   } else {
-                    curr = cont.i2() as Primitive
+                    curr = cont.effect_instruction_i2() as Primitive
                   }
                   break
                 }
@@ -525,42 +525,42 @@ export class STMDriver<in out R, out E, out A> {
                   break
                 }
                 case OpCodes.OP_WITH_STM_RUNTIME: {
-                  curr = current.i1(this as STMDriver<unknown, unknown, unknown>) as Primitive
+                  curr = current.effect_instruction_i1(this as STMDriver<unknown, unknown, unknown>) as Primitive
                   break
                 }
                 case OpCodes.OP_ON_SUCCESS:
                 case OpCodes.OP_ON_FAILURE:
                 case OpCodes.OP_ON_RETRY: {
                   this.pushStack(current)
-                  curr = current.i1 as Primitive
+                  curr = current.effect_instruction_i1 as Primitive
                   break
                 }
                 case OpCodes.OP_PROVIDE: {
                   const env = this.env
-                  this.env = current.i2(env)
+                  this.env = current.effect_instruction_i2(env)
                   curr = pipe(
-                    current.i1,
+                    current.effect_instruction_i1,
                     ensuring(sync(() => (this.env = env)))
                   ) as Primitive
                   break
                 }
                 case OpCodes.OP_SUCCEED: {
-                  const value = current.i1
+                  const value = current.effect_instruction_i1
                   const cont = this.nextSuccess()
                   if (cont === undefined) {
                     exit = TExit.succeed(value)
                   } else {
-                    curr = cont.i2(value) as Primitive
+                    curr = cont.effect_instruction_i2(value) as Primitive
                   }
                   break
                 }
                 case OpCodes.OP_SYNC: {
-                  const value = current.i1()
+                  const value = current.effect_instruction_i1()
                   const cont = this.nextSuccess()
                   if (cont === undefined) {
                     exit = TExit.succeed(value)
                   } else {
-                    curr = cont.i2(value) as Primitive
+                    curr = cont.effect_instruction_i2(value) as Primitive
                   }
                   break
                 }
@@ -590,8 +590,8 @@ export const catchAll = dual<
   ) => STM.STM<B | A, E1, R1 | R>
 >(2, (self, f) => {
   const stm = new STMPrimitive(OpCodes.OP_ON_FAILURE)
-  stm.i1 = self
-  stm.i2 = f
+  stm.effect_instruction_i1 = self
+  stm.effect_instruction_i2 = f
   return stm
 })
 
@@ -608,8 +608,8 @@ export const mapInputContext = dual<
   ) => STM.STM<A, E, R0>
 >(2, (self, f) => {
   const stm = new STMPrimitive(OpCodes.OP_PROVIDE)
-  stm.i1 = self
-  stm.i2 = f
+  stm.effect_instruction_i1 = self
+  stm.effect_instruction_i2 = f
   return stm
 })
 
@@ -622,7 +622,7 @@ export const dieMessage = (message: string): STM.STM<never> => dieSync(() => new
 /** @internal */
 export const dieSync = (evaluate: LazyArg<unknown>): STM.STM<never> => {
   const stm = new STMPrimitive(OpCodes.OP_DIE)
-  stm.i1 = evaluate
+  stm.effect_instruction_i1 = evaluate
   return stm as any
 }
 
@@ -647,7 +647,7 @@ export const fail = <E>(error: E): STM.STM<never, E> => failSync(() => error)
 /** @internal */
 export const failSync = <E>(evaluate: LazyArg<E>): STM.STM<never, E> => {
   const stm = new STMPrimitive(OpCodes.OP_FAIL)
-  stm.i1 = evaluate
+  stm.effect_instruction_i1 = evaluate
   return stm as any
 }
 
@@ -657,8 +657,8 @@ export const flatMap = dual<
   <A, E, R, A2, E1, R1>(self: STM.STM<A, E, R>, f: (a: A) => STM.STM<A2, E1, R1>) => STM.STM<A2, E1 | E, R1 | R>
 >(2, (self, f) => {
   const stm = new STMPrimitive(OpCodes.OP_ON_SUCCESS)
-  stm.i1 = self
-  stm.i2 = f
+  stm.effect_instruction_i1 = self
+  stm.effect_instruction_i2 = f
   return stm
 })
 
@@ -705,21 +705,21 @@ export const withSTMRuntime = <A, E = never, R = never>(
   f: (runtime: STMDriver<unknown, unknown, unknown>) => STM.STM<A, E, R>
 ): STM.STM<A, E, R> => {
   const stm = new STMPrimitive(OpCodes.OP_WITH_STM_RUNTIME)
-  stm.i1 = f
+  stm.effect_instruction_i1 = f
   return stm
 }
 
 /** @internal */
 export const interrupt: STM.STM<never> = withSTMRuntime((_) => {
   const stm = new STMPrimitive(OpCodes.OP_INTERRUPT)
-  stm.i1 = _.fiberId
+  stm.effect_instruction_i1 = _.fiberId
   return stm as any
 })
 
 /** @internal */
 export const interruptAs = (fiberId: FiberId.FiberId): STM.STM<never> => {
   const stm = new STMPrimitive(OpCodes.OP_INTERRUPT)
-  stm.i1 = fiberId
+  stm.effect_instruction_i1 = fiberId
   return stm as any
 }
 
@@ -742,8 +742,8 @@ export const orTry = dual<
   ) => STM.STM<A1 | A, E1 | E, R1 | R>
 >(2, (self, that) => {
   const stm = new STMPrimitive(OpCodes.OP_ON_RETRY)
-  stm.i1 = self
-  stm.i2 = that
+  stm.effect_instruction_i1 = self
+  stm.effect_instruction_i2 = that
   return stm
 })
 
@@ -753,14 +753,14 @@ export const retry: STM.STM<never> = new STMPrimitive(OpCodes.OP_RETRY)
 /** @internal */
 export const succeed = <A>(value: A): STM.STM<A> => {
   const stm = new STMPrimitive(OpCodes.OP_SUCCEED)
-  stm.i1 = value
+  stm.effect_instruction_i1 = value
   return stm as any
 }
 
 /** @internal */
 export const sync = <A>(evaluate: () => A): STM.STM<A> => {
   const stm = new STMPrimitive(OpCodes.OP_SYNC)
-  stm.i1 = evaluate
+  stm.effect_instruction_i1 = evaluate
   return stm as any
 }