@openrewrite/rewrite 8.70.0-20251222-101414 → 8.70.0-20251222-213047

package/src/json/rpc.ts

@@ -16,8 +16,7 @@
 import {JsonVisitor} from "./visitor";
 import {asRef, RpcCodecs, RpcReceiveQueue, RpcSendQueue} from "../rpc";
 import {Json} from "./tree";
-import {produceAsync} from "../visitor";
-import {createDraft, Draft, finishDraft} from "immer";
+import {updateIfChanged} from "../util";
 
 class JsonSender extends JsonVisitor<RpcSendQueue> {
 
@@ -98,30 +97,30 @@ class JsonSender extends JsonVisitor<RpcSendQueue> {
 class JsonReceiver extends JsonVisitor<RpcReceiveQueue> {
 
     protected async preVisit(j: Json, q: RpcReceiveQueue): Promise<Json | undefined> {
-        const draft = createDraft(j)
-        draft.id = await q.receive(j.id);
-        draft.prefix = await q.receive(j.prefix, async space => await this.visitSpace(space, q));
-        draft.markers = await q.receive(j.markers);
-        return finishDraft(draft);
+        return updateIfChanged(j, {
+            id: await q.receive(j.id),
+            prefix: await q.receive(j.prefix, async space => await this.visitSpace(space, q)),
+            markers: await q.receive(j.markers),
+        });
     }
 
     protected async visitDocument(document: Json.Document, q: RpcReceiveQueue): Promise<Json | undefined> {
-        const draft = createDraft(document);
-        draft.sourcePath = await q.receive(document.sourcePath);
-        draft.charsetName = await q.receive(document.charsetName);
-        draft.charsetBomMarked = await q.receive(document.charsetBomMarked);
-        draft.checksum = await q.receive(document.checksum);
-        draft.fileAttributes = await q.receive(document.fileAttributes);
-        draft.value = await q.receive<Json.Value>(document.value, async j => await this.visit(j, q)!);
-        draft.eof = await q.receive(document.eof, async space => await this.visitSpace(space, q));
-        return finishDraft(draft);
+        return updateIfChanged(document, {
+            sourcePath: await q.receive(document.sourcePath),
+            charsetName: await q.receive(document.charsetName),
+            charsetBomMarked: await q.receive(document.charsetBomMarked),
+            checksum: await q.receive(document.checksum),
+            fileAttributes: await q.receive(document.fileAttributes),
+            value: await q.receive<Json.Value>(document.value, async j => await this.visit(j, q)!),
+            eof: await q.receive(document.eof, async space => await this.visitSpace(space, q)),
+        });
     }
 
     protected async visitArray(array: Json.Array, q: RpcReceiveQueue): Promise<Json | undefined> {
-        const draft = createDraft(array);
-        draft.values = await q.receiveListDefined(array.values,
-            async j => await this.visitRightPadded(j, q)!)!;
-        return finishDraft(draft);
+        return updateIfChanged(array, {
+            values: await q.receiveListDefined(array.values,
+                async j => await this.visitRightPadded(j, q)!)!,
+        });
     }
 
     protected async visitEmpty(empty: Json.Empty): Promise<Json | undefined> {
@@ -129,56 +128,56 @@ class JsonReceiver extends JsonVisitor<RpcReceiveQueue> {
     }
 
     protected async visitIdentifier(identifier: Json.Identifier, q: RpcReceiveQueue): Promise<Json | undefined> {
-        const draft = createDraft(identifier);
-        draft.name = await q.receive(identifier.name);
-        return finishDraft(draft);
+        return updateIfChanged(identifier, {
+            name: await q.receive(identifier.name),
+        });
     }
 
     protected async visitLiteral(literal: Json.Literal, q: RpcReceiveQueue): Promise<Json | undefined> {
-        const draft = createDraft(literal);
-        draft.source = await q.receive(literal.source);
-        draft.value = await q.receive(literal.value);
-        return finishDraft(draft);
+        return updateIfChanged(literal, {
+            source: await q.receive(literal.source),
+            value: await q.receive(literal.value),
+        });
     }
 
     protected async visitMember(member: Json.Member, q: RpcReceiveQueue): Promise<Json | undefined> {
-        const draft = createDraft(member);
-        draft.key = await q.receive(member.key,
-            async j => await this.visitRightPadded(j, q)!)!;
-        draft.value = await q.receive<Json.Value>(member.value,
-            async j => await this.visit(j, q)!);
-        return finishDraft(draft);
+        return updateIfChanged(member, {
+            key: await q.receive(member.key,
+                async j => await this.visitRightPadded(j, q)!)!,
+            value: await q.receive<Json.Value>(member.value,
+                async j => await this.visit(j, q)!),
+        });
     }
 
     protected async visitObject(obj: Json.Object, q: RpcReceiveQueue): Promise<Json | undefined> {
-        const draft = createDraft(obj);
-        draft.members = await q.receiveListDefined(obj.members,
-            async j => await this.visitRightPadded(j, q));
-        return finishDraft(draft);
+        return updateIfChanged(obj, {
+            members: await q.receiveListDefined(obj.members,
+                async j => await this.visitRightPadded(j, q)),
+        });
     }
 
     public async visitSpace(space: Json.Space, q: RpcReceiveQueue): Promise<Json.Space> {
-        return (await produceAsync<Json.Space>(space, async draft => {
-            draft.comments = await q.receiveListDefined(space.comments, async c => {
-                return await produceAsync(c, async draft => {
-                    draft.multiline = await q.receive(c.multiline);
-                    draft.text = await q.receive(c.text);
-                    draft.suffix = await q.receive(c.suffix);
-                    draft.markers = await q.receive(c.markers);
-                })
-            });
-            draft.whitespace = await q.receive(space.whitespace);
-        }))!;
+        return updateIfChanged(space, {
+            comments: await q.receiveListDefined(space.comments, async c => {
+                return updateIfChanged(c, {
+                    multiline: await q.receive(c.multiline),
+                    text: await q.receive(c.text),
+                    suffix: await q.receive(c.suffix),
+                    markers: await q.receive(c.markers),
+                });
+            }),
+            whitespace: await q.receive(space.whitespace),
+        });
     }
 
     public async visitRightPadded<T extends Json>(right: Json.RightPadded<T>, p: RpcReceiveQueue): Promise<Json.RightPadded<T> | undefined> {
         if (!right) {
             throw new Error("TreeDataReceiveQueue should have instantiated an empty padding")
         }
-        return produceAsync<Json.RightPadded<T>>(right, async draft => {
-            draft.element = await p.receive(right.element, async j => await this.visit(j, p)!) as Draft<T>;
-            draft.after = await p.receive(right.after, async space => await this.visitSpace(space, p));
-            draft.markers = await p.receiveMarkers(right.markers);
+        return updateIfChanged(right, {
+            element: await p.receive(right.element, async j => await this.visit(j, p)!) as T,
+            after: await p.receive(right.after, async space => await this.visitSpace(space, p)),
+            markers: await p.receiveMarkers(right.markers),
         });
     }
 }

package/src/json/visitor.ts

@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 import {mapAsync, updateIfChanged} from "../util";
-import {produceAsync, TreeVisitor, ValidImmerRecipeReturnType} from "../visitor";
+import {TreeVisitor, ValidRecipeReturnType} from "../visitor";
 import {SourceFile} from "../tree";
 import {isJson, Json} from "./tree";
-import {createDraft, Draft, finishDraft} from "immer";
+import {create, Draft} from "mutative";
 
 export class JsonVisitor<P> extends TreeVisitor<Json, P> {
     async isAcceptable(sourceFile: SourceFile): Promise<boolean> {
@@ -103,19 +103,19 @@ export class JsonVisitor<P> extends TreeVisitor<Json, P> {
         before: Json | undefined,
         p: P,
         recipe?: (draft: Draft<J>) =>
-            ValidImmerRecipeReturnType<Draft<J>> |
-            PromiseLike<ValidImmerRecipeReturnType<Draft<J>>>
+            ValidRecipeReturnType<Draft<J>> |
+            PromiseLike<ValidRecipeReturnType<Draft<J>>>
     ): Promise<J | undefined> {
         if (before === undefined) {
             return undefined;
         }
-        const draft: Draft<J> = createDraft(before as J);
+        const [draft, finishDraft] = create(before as J);
         (draft as Draft<Json>).prefix = await this.visitSpace(before!.prefix, p);
         (draft as Draft<Json>).markers = await this.visitMarkers(before!.markers, p);
         if (recipe) {
             await recipe(draft);
         }
-        return finishDraft(draft) as J;
+        return finishDraft() as J;
     }
 
     protected accept(t: Json, p: P): Promise<Json | undefined> {

package/src/parse-error.ts

@@ -17,7 +17,7 @@ import {Cursor, SourceFile, Tree} from "./tree";
 import {TreeVisitor} from "./visitor";
 import {PrintOutputCapture, TreePrinters} from "./print";
 import {RpcCodecs, RpcReceiveQueue, RpcSendQueue} from "./rpc";
-import {createDraft, Draft, finishDraft} from "immer";
+import {updateIfChanged} from "./util";
 
 export const ParseErrorKind = "org.openrewrite.tree.ParseError";
 
@@ -67,16 +67,16 @@ TreePrinters.register(ParseErrorKind, () => new class extends ParseErrorVisitor<
 
 RpcCodecs.registerCodec(ParseErrorKind, {
     async rpcReceive(before: ParseError, q: RpcReceiveQueue): Promise<ParseError> {
-        const draft: Draft<ParseError> = createDraft(before);
-        draft.id = await q.receive(before.id);
-        draft.markers = await q.receive(before.markers);
-        draft.sourcePath = await q.receive(before.sourcePath);
-        draft.charsetName = await q.receive(before.charsetName);
-        draft.charsetBomMarked = await q.receive(before.charsetBomMarked);
-        draft.checksum = await q.receive(before.checksum);
-        draft.fileAttributes = await q.receive(before.fileAttributes);
-        draft.text = await q.receive(before.text);
-        return finishDraft(draft);
+        return updateIfChanged(before, {
+            id: await q.receive(before.id),
+            markers: await q.receive(before.markers),
+            sourcePath: await q.receive(before.sourcePath),
+            charsetName: await q.receive(before.charsetName),
+            charsetBomMarked: await q.receive(before.charsetBomMarked),
+            checksum: await q.receive(before.checksum),
+            fileAttributes: await q.receive(before.fileAttributes),
+            text: await q.receive(before.text),
+        });
     },
 
     async rpcSend(after: ParseError, q: RpcSendQueue): Promise<void> {

package/src/reference.ts

@@ -13,11 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import {setAutoFreeze} from "immer";
-
-// this is required because otherwise `asRef()` won't work for objects created using immer
-setAutoFreeze(false);
-
 const REFERENCE_KEY = Symbol.for("org.openrewrite.rpc.Reference");
 
 export interface Reference {

package/src/rpc/index.ts

@@ -15,9 +15,9 @@
  */
 import {Checksum, FileAttributes, TreeKind} from "../tree";
 import {RpcCodecs, RpcReceiveQueue, RpcSendQueue} from "./queue";
-import {createDraft, finishDraft} from "immer";
 import {Markers, MarkersKind, MarkupDebug, MarkupError, MarkupInfo, MarkupWarn, SearchResult} from "../markers";
 import {asRef} from "../reference";
+import {updateIfChanged} from "../util";
 
 export * from "./queue";
 export * from "../reference";
@@ -26,10 +26,10 @@ export * from "../reference";
 
 RpcCodecs.registerCodec(TreeKind.Checksum, {
     async rpcReceive(before: Checksum, q: RpcReceiveQueue): Promise<Checksum> {
-        const draft = createDraft(before);
-        draft.algorithm = await q.receive(before.algorithm);
-        draft.value = await q.receive(before.value);
-        return finishDraft(draft) as Checksum;
+        return updateIfChanged(before, {
+            algorithm: await q.receive(before.algorithm),
+            value: await q.receive(before.value),
+        });
     },
 
     async rpcSend(after: Checksum, q: RpcSendQueue): Promise<void> {
@@ -40,15 +40,15 @@ RpcCodecs.registerCodec(TreeKind.Checksum, {
 
 RpcCodecs.registerCodec(TreeKind.FileAttributes, {
     async rpcReceive(before: FileAttributes, q: RpcReceiveQueue): Promise<FileAttributes> {
-        const draft = createDraft(before);
-        draft.creationDate = await q.receive(before.creationDate);
-        draft.lastModifiedTime = await q.receive(before.lastModifiedTime);
-        draft.lastAccessTime = await q.receive(before.lastAccessTime);
-        draft.isReadable = await q.receive(before.isReadable);
-        draft.isWritable = await q.receive(before.isWritable);
-        draft.isExecutable = await q.receive(before.isExecutable);
-        draft.size = await q.receive(before.size);
-        return finishDraft(draft) as FileAttributes;
+        return updateIfChanged(before, {
+            creationDate: await q.receive(before.creationDate),
+            lastModifiedTime: await q.receive(before.lastModifiedTime),
+            lastAccessTime: await q.receive(before.lastAccessTime),
+            isReadable: await q.receive(before.isReadable),
+            isWritable: await q.receive(before.isWritable),
+            isExecutable: await q.receive(before.isExecutable),
+            size: await q.receive(before.size),
+        });
     },
 
     async rpcSend(after: FileAttributes, q: RpcSendQueue): Promise<void> {
@@ -63,11 +63,11 @@ RpcCodecs.registerCodec(TreeKind.FileAttributes, {
 });
 
 RpcCodecs.registerCodec(MarkersKind.Markers, {
-    async rpcReceive(before: Markers, q: RpcReceiveQueue): Promise<any> {
-        const draft = createDraft(before);
-        draft.id = await q.receive(before.id);
-        draft.markers = (await q.receiveList(before.markers))!;
-        return finishDraft(draft);
+    async rpcReceive(before: Markers, q: RpcReceiveQueue): Promise<Markers> {
+        return updateIfChanged(before, {
+            id: await q.receive(before.id),
+            markers: (await q.receiveList(before.markers))!,
+        });
     },
 
     async rpcSend(after: Markers, q: RpcSendQueue): Promise<void> {
@@ -79,10 +79,10 @@ RpcCodecs.registerCodec(MarkersKind.Markers, {
 // Register codecs for all Java markers with additional properties
 RpcCodecs.registerCodec(MarkersKind.SearchResult, {
     async rpcReceive(before: SearchResult, q: RpcReceiveQueue): Promise<SearchResult> {
-        const draft = createDraft(before);
-        draft.id = await q.receive(before.id);
-        draft.description = await q.receive(before.description)
-        return finishDraft(draft);
+        return updateIfChanged(before, {
+            id: await q.receive(before.id),
+            description: await q.receive(before.description),
+        });
     },
 
     async rpcSend(after: SearchResult, q: RpcSendQueue): Promise<void> {
@@ -93,11 +93,11 @@ RpcCodecs.registerCodec(MarkersKind.SearchResult, {
 
 RpcCodecs.registerCodec(MarkersKind.MarkupError, {
     async rpcReceive(before: MarkupError, q: RpcReceiveQueue): Promise<MarkupError> {
-        const draft = createDraft(before);
-        draft.id = await q.receive(before.id);
-        draft.message = await q.receive(before.message);
-        draft.detail = await q.receive(before.detail);
-        return finishDraft(draft);
+        return updateIfChanged(before, {
+            id: await q.receive(before.id),
+            message: await q.receive(before.message),
+            detail: await q.receive(before.detail),
+        });
     },
 
     async rpcSend(after: MarkupError, q: RpcSendQueue): Promise<void> {
@@ -109,11 +109,11 @@ RpcCodecs.registerCodec(MarkersKind.MarkupError, {
 
 RpcCodecs.registerCodec(MarkersKind.MarkupWarn, {
     async rpcReceive(before: MarkupWarn, q: RpcReceiveQueue): Promise<MarkupWarn> {
-        const draft = createDraft(before);
-        draft.id = await q.receive(before.id);
-        draft.message = await q.receive(before.message);
-        draft.detail = await q.receive(before.detail);
-        return finishDraft(draft);
+        return updateIfChanged(before, {
+            id: await q.receive(before.id),
+            message: await q.receive(before.message),
+            detail: await q.receive(before.detail),
+        });
     },
 
     async rpcSend(after: MarkupWarn, q: RpcSendQueue): Promise<void> {
@@ -125,11 +125,11 @@ RpcCodecs.registerCodec(MarkersKind.MarkupWarn, {
 
 RpcCodecs.registerCodec(MarkersKind.MarkupInfo, {
     async rpcReceive(before: MarkupInfo, q: RpcReceiveQueue): Promise<MarkupInfo> {
-        const draft = createDraft(before);
-        draft.id = await q.receive(before.id);
-        draft.message = await q.receive(before.message);
-        draft.detail = await q.receive(before.detail);
-        return finishDraft(draft);
+        return updateIfChanged(before, {
+            id: await q.receive(before.id),
+            message: await q.receive(before.message),
+            detail: await q.receive(before.detail),
+        });
     },
 
     async rpcSend(after: MarkupInfo, q: RpcSendQueue): Promise<void> {
@@ -141,11 +141,11 @@ RpcCodecs.registerCodec(MarkersKind.MarkupInfo, {
 
 RpcCodecs.registerCodec(MarkersKind.MarkupDebug, {
     async rpcReceive(before: MarkupDebug, q: RpcReceiveQueue): Promise<MarkupDebug> {
-        const draft = createDraft(before);
-        draft.id = await q.receive(before.id);
-        draft.message = await q.receive(before.message);
-        draft.detail = await q.receive(before.detail);
-        return finishDraft(draft);
+        return updateIfChanged(before, {
+            id: await q.receive(before.id),
+            message: await q.receive(before.message),
+            detail: await q.receive(before.detail),
+        });
     },
 
     async rpcSend(after: MarkupDebug, q: RpcSendQueue): Promise<void> {

package/src/rpc/queue.ts

@@ -16,7 +16,7 @@
 import * as rpc from "vscode-jsonrpc/node";
 import {emptyMarkers, Markers} from "../markers";
 import {saveTrace, trace} from "./trace";
-import {createDraft, finishDraft} from "immer";
+import {updateIfChanged} from "../util";
 import {isRef, ReferenceMap} from "../reference";
 
 /**
@@ -288,10 +288,10 @@ export class RpcReceiveQueue {
         }
         return this.receive(markers, async m => {
             return saveTrace(this.trace, async () => {
-                const draft = createDraft(markers!);
-                draft.id = await this.receive(m.id);
-                draft.markers = (await this.receiveList(m.markers))!;
-                return finishDraft(draft);
+                return updateIfChanged(markers!, {
+                    id: await this.receive(m.id),
+                    markers: (await this.receiveList(m.markers))!,
+                });
             })
         })
     }
@@ -397,9 +397,7 @@ export class RpcReceiveQueue {
     }
 
     private newObj<T>(type: string): T {
-        return {
-            kind: type
-        } as T;
+        return {kind: type} as T;
     }
 }
 

package/src/rpc/request/install-recipes.ts

@@ -182,7 +182,7 @@ function preloadCoreModules(logger?: rpc.Logger) {
  * same package is installed in multiple node_modules directories.
  */
 function setupSharedDependencies(targetModulePath: string, logger?: rpc.Logger) {
-    const sharedDeps = ['@openrewrite/rewrite', 'vscode-jsonrpc'];
+    const sharedDeps = ['@openrewrite/rewrite', 'vscode-jsonrpc', 'mutative'];
     const targetDir = path.dirname(targetModulePath);
 
     sharedDeps.forEach(depName => {

package/src/rpc/request/parse-project.ts

@@ -17,11 +17,11 @@ import * as rpc from "vscode-jsonrpc/node";
 import * as path from "path";
 import {ExecutionContext} from "../../execution";
 import {randomId, UUID} from "../../uuid";
-import {produce} from "immer";
 import {SourceFile} from "../../tree";
 import {Parsers} from "../../parser";
 import {withMetrics} from "./metrics";
 import {DEFAULT_EXCLUSIONS, ProjectParser} from "../../javascript";
+import {replaceMarkerByKind} from "../../markers";
 
 /**
  * Response item with object ID and source file type for proper deserialization.
@@ -82,9 +82,7 @@ export class ParseProject {
                             const id = randomId();
                             localObjects.set(id, async (id: string) => {
                                 const sourceFile: SourceFile = (await generator.next()).value;
-                                return produce(sourceFile, (draft) => {
-                                    draft.id = id;
-                                });
+                                return { ...sourceFile, id };
                             });
                             resultItems.push({
                                 id,
@@ -102,9 +100,7 @@ export class ParseProject {
                             const id = randomId();
                             localObjects.set(id, async (id: string) => {
                                 const sourceFile: SourceFile = (await generator.next()).value;
-                                return produce(sourceFile, (draft) => {
-                                    draft.id = id;
-                                });
+                                return { ...sourceFile, id };
                             });
                             resultItems.push({
                                 id,
@@ -122,9 +118,7 @@ export class ParseProject {
                             const id = randomId();
                             localObjects.set(id, async (id: string) => {
                                 const sourceFile: SourceFile = (await generator.next()).value;
-                                return produce(sourceFile, (draft) => {
-                                    draft.id = id;
-                                });
+                                return { ...sourceFile, id };
                             });
                             resultItems.push({
                                 id,
@@ -142,9 +136,7 @@ export class ParseProject {
                             const id = randomId();
                             localObjects.set(id, async (id: string) => {
                                 const sourceFile: SourceFile = (await generator.next()).value;
-                                return produce(sourceFile, (draft) => {
-                                    draft.id = id;
-                                });
+                                return { ...sourceFile, id };
                             });
                             resultItems.push({
                                 id,
@@ -173,12 +165,13 @@ export class ParseProject {
                                     const sourceFile: SourceFile = (await generator.next()).value;
                                     // Add PrettierStyle marker if Prettier is available
                                     const prettierMarker = await prettierLoader.getConfigMarker(filePath);
-                                    return produce(sourceFile, (draft) => {
-                                        draft.id = id;
-                                        if (prettierMarker) {
-                                            draft.markers.markers = draft.markers.markers.concat([prettierMarker]);
-                                        }
-                                    });
+                                    return {
+                                        ...sourceFile,
+                                        id,
+                                        markers: prettierMarker
+                                            ? replaceMarkerByKind(sourceFile.markers, prettierMarker)
+                                            : sourceFile.markers
+                                    };
                                 });
                                 resultItems.push({
                                     id,
@@ -202,10 +195,11 @@ export class ParseProject {
                             // Store thunks that add the Autodetect marker
                             for (const {id, sourceFile} of parsedFiles) {
                                 localObjects.set(id, async (newId: string) => {
-                                    return produce(sourceFile, (draft) => {
-                                        draft.id = newId;
-                                        draft.markers.markers = draft.markers.markers.concat([autodetectMarker]);
-                                    });
+                                    return {
+                                        ...sourceFile,
+                                        id: newId,
+                                        markers: replaceMarkerByKind(sourceFile.markers, autodetectMarker)
+                                    };
                                 });
                                 resultItems.push({
                                     id,
@@ -224,9 +218,7 @@ export class ParseProject {
                             const id = randomId();
                             localObjects.set(id, async (id: string) => {
                                 const sourceFile: SourceFile = (await generator.next()).value;
-                                return produce(sourceFile, (draft) => {
-                                    draft.id = id;
-                                });
+                                return { ...sourceFile, id };
                             });
                             resultItems.push({
                                 id,
@@ -244,9 +236,7 @@ export class ParseProject {
                             const id = randomId();
                             localObjects.set(id, async (id: string) => {
                                 const sourceFile: SourceFile = (await generator.next()).value;
-                                return produce(sourceFile, (draft) => {
-                                    draft.id = id;
-                                });
+                                return { ...sourceFile, id };
                             });
                             resultItems.push({
                                 id,
@@ -264,9 +254,7 @@ export class ParseProject {
                             const id = randomId();
                             localObjects.set(id, async (id: string) => {
                                 const sourceFile: SourceFile = (await generator.next()).value;
-                                return produce(sourceFile, (draft) => {
-                                    draft.id = id;
-                                });
+                                return { ...sourceFile, id };
                             });
                             resultItems.push({
                                 id,

package/src/rpc/request/parse.ts

@@ -17,7 +17,6 @@ import * as rpc from "vscode-jsonrpc/node";
 import {ExecutionContext} from "../../execution";
 import {ParserInput, parserInputFile, Parsers, ParserType} from "../../parser";
 import {randomId, UUID} from "../../uuid";
-import {produce} from "immer";
 import {SourceFile} from "../../tree";
 import {withMetrics} from "./metrics";
 import * as path from "path";
@@ -70,9 +69,7 @@ export class Parse {
                         const id = randomId();
                         localObjects.set(id, async (id: string) => {
                             const sourceFile: SourceFile = (await generator.next()).value;
-                            return produce(sourceFile, (draft) => {
-                                draft.id = id;
-                            });
+                            return { ...sourceFile, id };
                         });
                         resultIds.push(id);
                     }

package/src/text/rpc.ts

@@ -15,31 +15,31 @@
  */
 import {RpcCodecs, RpcReceiveQueue, RpcSendQueue} from "../rpc";
 import {PlainText} from "./tree";
-import {createDraft, Draft, finishDraft} from "immer";
+import {updateIfChanged} from "../util";
 
 async function receiveSnippet(before: PlainText.Snippet, q: RpcReceiveQueue): Promise<PlainText.Snippet | undefined> {
-    const draft: Draft<PlainText.Snippet> = createDraft(before);
-    draft.id = await q.receive(before.id);
-    draft.markers = await q.receive(before.markers);
-    draft.text = await q.receive(before.text);
-    return finishDraft(draft);
+    return updateIfChanged(before, {
+        id: await q.receive(before.id),
+        markers: await q.receive(before.markers),
+        text: await q.receive(before.text),
+    });
 }
 
-// Register codec for all Java AST node types
+// Register codec for all PlainText AST node types
 for (const kind of Object.values(PlainText.Kind)) {
     RpcCodecs.registerCodec(kind as string, {
         async rpcReceive(before: PlainText, q: RpcReceiveQueue): Promise<PlainText> {
-            const draft: Draft<PlainText> = createDraft(before);
-            draft.id = await q.receive(before.id);
-            draft.markers = await q.receive(before.markers);
-            draft.sourcePath = await q.receive(before.sourcePath);
-            draft.charsetName = await q.receive(before.charsetName);
-            draft.charsetBomMarked = await q.receive(before.charsetBomMarked);
-            draft.checksum = await q.receive(before.checksum);
-            draft.fileAttributes = await q.receive(before.fileAttributes);
-            draft.text = await q.receive(before.text);
-            draft.snippets = (await q.receiveList(before.snippets, snippet => receiveSnippet(snippet, q)))!;
-            return finishDraft(draft);
+            return updateIfChanged(before, {
+                id: await q.receive(before.id),
+                markers: await q.receive(before.markers),
+                sourcePath: await q.receive(before.sourcePath),
+                charsetName: await q.receive(before.charsetName),
+                charsetBomMarked: await q.receive(before.charsetBomMarked),
+                checksum: await q.receive(before.checksum),
+                fileAttributes: await q.receive(before.fileAttributes),
+                text: await q.receive(before.text),
+                snippets: (await q.receiveList(before.snippets, snippet => receiveSnippet(snippet, q)))!,
+            });
         },
 
         async rpcSend(after: PlainText, q: RpcSendQueue): Promise<void> {