diff --git a/packages/effect-lens/src/Lens.ts b/packages/effect-lens/src/Lens.ts
index a5d1082..1ca5127 100644
--- a/packages/effect-lens/src/Lens.ts
+++ b/packages/effect-lens/src/Lens.ts
@@ -55,7 +55,7 @@ extends Pipeable.Class() implements Lens<A, ER, EW, RR, RW> {
     abstract readonly changes: Stream.Stream<A, ER, RR>
     abstract readonly lock: Effect.Effect<LensImpl.Lock, EW, RW>
 
-    get get() { return Effect.map(this.resolve, frame => frame.value) }
+    get get() { return Effect.map(this.resolve, resolved => resolved.value) }
 
     modifyEffect<B, E1 = never, R1 = never>(
         f: (a: A) => Effect.Effect<readonly [B, A], E1, R1>,
@@ -64,9 +64,9 @@ extends Pipeable.Class() implements Lens<A, ER, EW, RR, RW> {
             this.lock,
             lock => lock(Effect.flatMap(
                 this.resolve,
-                frame => Effect.flatMap(
-                    f(frame.value),
-                    ([c, next]) => Effect.as(frame.commit(Effect.succeed(next)), c),
+                resolved => Effect.flatMap(
+                    f(resolved.value),
+                    ([c, next]) => Effect.as(resolved.commit(Effect.succeed(next)), c),
                 ),
             )),
         )
@@ -133,9 +133,9 @@ extends LensImpl<A, ER | E1, EW | E1, RR | R1, RW | R1> {
     get resolve(): Effect.Effect<LensImpl.Resolved<A, EW | E1, RW | R1>, ER | E1, RR | R1> {
         return Effect.map(
             Effect.flatMap(this.effect, l => asLensImpl(l).resolve),
-            frame => ({
-                value: frame.value,
-                commit: next => frame.commit(next),
+            resolved => ({
+                value: resolved.value,
+                commit: next => resolved.commit(next),
             }),
         )
     }
@@ -357,9 +357,9 @@ export const map: {
 ): Lens<B, ER, EW, RR, RW> => derive(self, {
     resolve: parent => Effect.map(
         parent,
-        frame => ({
-            value: get(frame.value),
-            commit: next => frame.commit(Effect.map(next, b => set(frame.value, b))),
+        resolved => ({
+            value: get(resolved.value),
+            commit: next => resolved.commit(Effect.map(next, b => set(resolved.value, b))),
         }),
     ),
     mapStream: Stream.map(get),
@@ -386,11 +386,11 @@ export const mapEffect: {
 ): Lens<B, ER | EGet, EW | ESet, RR | RGet, RW | RSet> => derive(self, {
     resolve: parent => Effect.flatMap(
         parent,
-        frame => Effect.map(
-            get(frame.value),
+        resolved => Effect.map(
+            get(resolved.value),
             value => ({
                 value,
-                commit: next => frame.commit(Effect.flatMap(next, b => set(frame.value, b))),
+                commit: next => resolved.commit(Effect.flatMap(next, b => set(resolved.value, b))),
             }),
         ),
     ),
@@ -525,11 +525,11 @@ export const mapErrorWrite: {
     self: Lens<A, ER, EW, RR, RW>,
     f: (error: NoInfer<EW>) => E2,
 ): Lens<A, ER, E2, RR, RW> => derive(self, {
-    resolve: parent => Effect.map(parent, frame => ({
-        value: frame.value,
+    resolve: parent => Effect.map(parent, resolved => ({
+        value: resolved.value,
         commit: next => Effect.flatMap(
             next,
-            value => Effect.mapError(frame.commit(Effect.succeed(value)), f),
+            value => Effect.mapError(resolved.commit(Effect.succeed(value)), f),
         ),
     })),
     mapStream: identity,
@@ -556,11 +556,11 @@ export const mapError: {
 ): Lens<A, E2, E2, RR, RW> => derive(self, {
     resolve: parent => Effect.map(
         Effect.mapError(parent, f),
-        frame => ({
-            value: frame.value,
+        resolved => ({
+            value: resolved.value,
             commit: next => Effect.flatMap(
                 next,
-                value => Effect.mapError(frame.commit(Effect.succeed(value)), f),
+                value => Effect.mapError(resolved.commit(Effect.succeed(value)), f),
             ),
         }),
     ),
@@ -608,11 +608,11 @@ export const tapErrorWrite: {
     self: Lens<A, ER, EW, RR, RW>,
     f: (error: NoInfer<EW>) => Effect.Effect<unknown, E2, R2>,
 ): Lens<A, ER, EW | E2, RR, RW | R2> => derive(self, {
-    resolve: parent => Effect.map(parent, frame => ({
-        value: frame.value,
+    resolve: parent => Effect.map(parent, resolved => ({
+        value: resolved.value,
         commit: next => Effect.flatMap(
             next,
-            value => Effect.tapError(frame.commit(Effect.succeed(value)), f),
+            value => Effect.tapError(resolved.commit(Effect.succeed(value)), f),
         ),
     })),
     mapStream: identity,
@@ -639,11 +639,11 @@ export const tapError: {
 ): Lens<A, ER | E2, EW | E2, RR | R2, RW | R2> => derive(self, {
     resolve: parent => Effect.map(
         Effect.tapError(parent, f),
-        frame => ({
-            value: frame.value,
+        resolved => ({
+            value: resolved.value,
             commit: next => Effect.flatMap(
                 next,
-                value => Effect.tapError(frame.commit(Effect.succeed(value)), f),
+                value => Effect.tapError(resolved.commit(Effect.succeed(value)), f),
             ),
         }),
     ),
@@ -669,9 +669,9 @@ export const provideContext: {
 ): Lens<A, ER, EW, Exclude<RR, R2>, Exclude<RW, R2>> => derive(self, {
     resolve: parent => Effect.map(
         Effect.provide(parent, context),
-        frame => ({
-            value: frame.value,
-            commit: next => Effect.provide(frame.commit(next), context),
+        resolved => ({
+            value: resolved.value,
+            commit: next => Effect.provide(resolved.commit(next), context),
         }),
     ),
     mapStream: Stream.provideSomeContext(context),
@@ -701,9 +701,9 @@ export const provideService: {
 ): Lens<A, ER, EW, Exclude<RR, I>, Exclude<RW, I>> => derive(self, {
     resolve: parent => Effect.map(
         Effect.provideService(parent, tag, service),
-        frame => ({
-            value: frame.value,
-            commit: next => Effect.provideService(frame.commit(next), tag, service),
+        resolved => ({
+            value: resolved.value,
+            commit: next => Effect.provideService(resolved.commit(next), tag, service),
         }),
     ),
     mapStream: Stream.provideService(tag, service),