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

package/src/javascript/node-resolution-result.ts

@@ -17,7 +17,7 @@ import {findMarker, Marker, Markers} from "../markers";
 import {randomId, UUID} from "../uuid";
 import {asRef} from "../reference";
 import {RpcCodecs, RpcReceiveQueue, RpcSendQueue} from "../rpc";
-import {castDraft} from "immer";
+import {castDraft} from "mutative";
 import {updateIfChanged} from "../util";
 import * as semver from "semver";
 import * as fsp from "fs/promises";
@@ -295,7 +295,7 @@ export function createNodeResolutionResultMarker(
     function extractPackageInfo(pkgPath: string): { name: string; version?: string } {
         // For nested packages, we want the last package name
         const nodeModulesIndex = pkgPath.lastIndexOf('node_modules/');
-        if (nodeModulesIndex === -1) return { name: pkgPath };
+        if (nodeModulesIndex === -1) return {name: pkgPath};
 
         let nameWithVersion = pkgPath.slice(nodeModulesIndex + 'node_modules/'.length);
 
@@ -320,7 +320,7 @@ export function createNodeResolutionResultMarker(
             }
         }
 
-        return { name: nameWithVersion };
+        return {name: nameWithVersion};
     }
 
     /**
@@ -347,7 +347,7 @@ export function createNodeResolutionResultMarker(
                 optionalDependencies: undefined,
                 engines: normalizeEngines(pkgEntry?.engines),
                 license: normalizeLicense(pkgEntry?.license),
-            });
+            }) as ResolvedDependency;
             resolvedDependencyCache.set(key, resolved);
 
             // Maintain name index for O(1) lookup during semver fallback
@@ -470,7 +470,7 @@ export function createNodeResolutionResultMarker(
                 name,
                 versionConstraint,
                 resolved,
-            });
+            }) as Dependency;
             dependencyCache.set(key, dep);
         }
         return dep;
@@ -514,7 +514,7 @@ export function createNodeResolutionResultMarker(
         const packages = lockContent.packages;
 
         // First pass: Create all ResolvedDependency placeholders and build path map
-        const packageInfos: Array<{path: string; name: string; version: string; entry: PackageLockEntry}> = [];
+        const packageInfos: Array<{ path: string; name: string; version: string; entry: PackageLockEntry }> = [];
         for (const [pkgPath, pkgEntry] of Object.entries(packages)) {
             // Skip the root package (empty string key)
             if (pkgPath === '') continue;
@@ -535,7 +535,7 @@ export function createNodeResolutionResultMarker(
         // Note: Using castDraft here is safe because all objects are created within this
         // parsing context and haven't been returned to callers yet. The objects in
         // resolvedDependencyCache are plain JS objects marked with asRef() for RPC
-        // reference deduplication, not frozen Immer drafts.
+        // reference deduplication.
         for (const {path: pkgPath, name, version, entry} of packageInfos) {
             const key = `${name}@${version}`;
             const resolved = resolvedDependencyCache.get(key);
@@ -590,7 +590,7 @@ export function createNodeResolutionResultMarker(
         packageManager,
         engines: packageJsonContent.engines,
         npmrcConfigs,
-    };
+    } as NodeResolutionResult;
 }
 
 /**
@@ -817,7 +817,6 @@ export namespace NodeResolutionResultQueries {
 RpcCodecs.registerCodec(NpmrcKind, {
     async rpcReceive(before: Npmrc, q: RpcReceiveQueue): Promise<Npmrc> {
         return updateIfChanged(before, {
-            kind: NpmrcKind,
             scope: await q.receive(before.scope),
             properties: await q.receive(before.properties),
         });
@@ -835,7 +834,6 @@ RpcCodecs.registerCodec(NpmrcKind, {
 RpcCodecs.registerCodec(DependencyKind, {
     async rpcReceive(before: Dependency, q: RpcReceiveQueue): Promise<Dependency> {
         return updateIfChanged(before, {
-            kind: DependencyKind,
             name: await q.receive(before.name),
             versionConstraint: await q.receive(before.versionConstraint),
             resolved: await q.receive(before.resolved),
@@ -855,7 +853,6 @@ RpcCodecs.registerCodec(DependencyKind, {
 RpcCodecs.registerCodec(ResolvedDependencyKind, {
     async rpcReceive(before: ResolvedDependency, q: RpcReceiveQueue): Promise<ResolvedDependency> {
         return updateIfChanged(before, {
-            kind: ResolvedDependencyKind,
             name: await q.receive(before.name),
             version: await q.receive(before.version),
             dependencies: (await q.receiveList(before.dependencies)) || undefined,
@@ -886,9 +883,6 @@ RpcCodecs.registerCodec(ResolvedDependencyKind, {
 /**
  * Register RPC codec for NodeResolutionResult marker.
  * This handles serialization/deserialization for communication between JS and Java.
- * Note: We avoid Immer here because the dependency graph can contain cycles
- * (e.g., Dependency -> ResolvedDependency -> Dependency[]), and Immer's proxies
- * don't handle cyclic structures correctly.
  */
 RpcCodecs.registerCodec(NodeResolutionResultKind, {
     async rpcReceive(before: NodeResolutionResult, q: RpcReceiveQueue): Promise<NodeResolutionResult> {

package/src/javascript/parser.ts

@@ -30,7 +30,7 @@ import {
     VariableDeclarator,
 } from '../java';
 import {DelegatedYield, FunctionDeclaration, Generator, JS, JSX, NonNullAssertion, Optional, Spread} from '.';
-import {emptyMarkers, markers, Markers, MarkersKind, ParseExceptionResult} from "../markers";
+import {emptyMarkers, markers, Markers, MarkersKind, ParseExceptionResult, replaceMarkerByKind} from "../markers";
 import {NamedStyles} from "../style";
 import {Parser, ParserInput, parserInputFile, parserInputRead, ParserOptions, Parsers, SourcePath} from "../parser";
 import {randomId} from "../uuid";
@@ -47,10 +47,11 @@ import {
     TextSpan
 } from "./parser-utils";
 import {JavaScriptTypeMapping} from "./type-mapping";
-import {produce} from "immer";
+import {create as produce} from "mutative";
 import ComputedPropertyName = JS.ComputedPropertyName;
 import Attribute = JSX.Attribute;
 import SpreadAttribute = JSX.SpreadAttribute;
+
 export interface JavaScriptParserOptions extends ParserOptions {
     styles?: NamedStyles[],
     sourceFileCache?: Map<string, ts.SourceFile>,
@@ -168,7 +169,7 @@ export class JavaScriptParser extends Parser {
             if (this.styles) {
                 const styles = this.styles;
                 return produce(result, draft => {
-                    draft.markers.markers = draft.markers.markers.concat(styles);
+                    draft.markers = styles.reduce((m, s) => replaceMarkerByKind(m, s), draft.markers);
                 });
             }
             return result;
@@ -359,7 +360,7 @@ export class JavaScriptParser extends Parser {
                         .visit(sourceFile) as SourceFile,
                     draft => {
                         if (this.styles) {
-                            draft.markers.markers = draft.markers.markers.concat(this.styles);
+                            draft.markers = this.styles.reduce((m, s) => replaceMarkerByKind(m, s), draft.markers);
                         }
                     });
             } catch (error) {

package/src/javascript/project-parser.ts

@@ -18,12 +18,12 @@ import * as fs from "fs";
 import * as fsp from "fs/promises";
 import {spawnSync} from "child_process";
 import picomatch from "picomatch";
-import {produce} from "immer";
+import {create as produce} from "mutative";
 import {SourceFile} from "../tree";
 import {Parsers} from "../parser";
 import {PrettierConfigLoader} from "./format/prettier-config-loader";
 import {ExecutionContext} from "../execution";
-import {Marker} from "../markers";
+import {Marker, replaceMarkerByKind} from "../markers";
 
 // Lock file names defined here to avoid circular dependency with package-manager.ts
 // These must be kept in sync with the definitions in package-manager.ts
@@ -303,7 +303,7 @@ export class ProjectParser {
                     );
                     if (prettierMarker) {
                         yield produce(sf, draft => {
-                            draft.markers.markers = draft.markers.markers.concat([prettierMarker]);
+                            draft.markers = replaceMarkerByKind(draft.markers, prettierMarker);
                         });
                     } else {
                         yield sf;
@@ -341,7 +341,7 @@ export class ProjectParser {
                 // Yield all files with the Autodetect marker
                 for (const sf of parsedFiles) {
                     yield produce(sf, draft => {
-                        draft.markers.markers = draft.markers.markers.concat([autodetectMarker]);
+                        draft.markers = replaceMarkerByKind(draft.markers, autodetectMarker);
                     });
                 }
             }

package/src/javascript/recipes/auto-format.ts

@@ -14,93 +14,31 @@
  * limitations under the License.
  */
 
-import {ScanningRecipe} from "../../recipe";
+import {Recipe} from "../../recipe";
 import {TreeVisitor} from "../../visitor";
 import {ExecutionContext} from "../../execution";
 import {AutoformatVisitor} from "../format";
-import {Autodetect, Detector} from "../autodetect";
-import {JavaScriptVisitor} from "../visitor";
-import {JS} from "../tree";
-import {J} from "../../java";
-import {findMarker, MarkersKind} from "../../markers";
-import {StyleKind} from "../style";
-import {NamedStyles} from "../../style";
-
-/**
- * Accumulator for the AutoFormat scanning recipe.
- * Holds the Detector that collects formatting statistics during the scan phase.
- */
-interface AutoFormatAccumulator {
-    detector: Detector;
-    detectedStyles?: Autodetect;
-}
-
-/**
- * Checks if a compilation unit already has formatting styles attached.
- * Returns true if either PrettierStyle or Autodetect markers are present.
- */
-function hasFormattingStyles(cu: JS.CompilationUnit): boolean {
-    // Check for PrettierStyle marker
-    if (findMarker(cu, StyleKind.PrettierStyle)) {
-        return true;
-    }
-
-    // Check for Autodetect marker (NamedStyles with specific name)
-    const namedStyles = cu.markers.markers.filter(
-        m => m.kind === MarkersKind.NamedStyles
-    ) as NamedStyles[];
-
-    return namedStyles.some(s => s.name === "org.openrewrite.javascript.Autodetect");
-}
 
 /**
  * Formats JavaScript/TypeScript code using a comprehensive set of formatting rules.
  *
- * This is a scanning recipe that:
- * 1. Scans all source files to detect the project's existing formatting style
- * 2. Applies consistent formatting based on the detected style
+ * This recipe applies formatting based on styles detected at parse time:
+ * - If PrettierStyle marker is present, uses Prettier formatting
+ * - If Autodetect marker is present, uses auto-detected project style
+ * - Otherwise, defaults to IntelliJ IDEA style
  *
  * The detected formatting includes:
  * - Tabs vs spaces preference
  * - Indent size (2, 4, etc.)
  * - ES6 import/export brace spacing
- *
- * If no clear style is detected, defaults to IntelliJ IDEA style.
- *
- * Files with existing formatting styles (PrettierStyle or Autodetect markers)
- * are skipped during style detection since they already have their formatting configured.
  */
-export class AutoFormat extends ScanningRecipe<AutoFormatAccumulator> {
+export class AutoFormat extends Recipe {
     readonly name = "org.openrewrite.javascript.format.auto-format";
     readonly displayName = "Auto-format JavaScript/TypeScript code";
     readonly description = "Format JavaScript and TypeScript code using formatting rules auto-detected from the project's existing code style.";
 
-    initialValue(_ctx: ExecutionContext): AutoFormatAccumulator {
-        return {
-            detector: Autodetect.detector()
-        };
-    }
-
-    async scanner(acc: AutoFormatAccumulator): Promise<TreeVisitor<any, ExecutionContext>> {
-        return new class extends JavaScriptVisitor<ExecutionContext> {
-            protected async visitJsCompilationUnit(cu: JS.CompilationUnit, ctx: ExecutionContext): Promise<J | undefined> {
-                // Skip sampling files that already have formatting styles attached
-                if (!hasFormattingStyles(cu)) {
-                    await acc.detector.sample(cu);
-                }
-                return cu;
-            }
-        };
-    }
-
-    async editorWithData(acc: AutoFormatAccumulator): Promise<TreeVisitor<any, ExecutionContext>> {
-        // Build detected styles once (lazily on first edit)
-        if (!acc.detectedStyles) {
-            acc.detectedStyles = acc.detector.build();
-        }
-
-        // Pass detected styles to the AutoformatVisitor
-        // Autodetect is a NamedStyles, so pass it as an array
-        return new AutoformatVisitor(undefined, [acc.detectedStyles]);
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        // AutoformatVisitor looks up styles from source file markers
+        return new AutoformatVisitor();
     }
 }

package/src/javascript/recipes/change-import.ts

@@ -20,7 +20,7 @@ import {ExecutionContext} from "../../execution";
 import {JavaScriptVisitor, JS} from "../index";
 import {maybeAddImport} from "../add-import";
 import {J, isIdentifier, Type} from "../../java";
-import {produce, WritableDraft} from "immer";
+import {create as produce, Draft} from "mutative";
 
 /**
  * Changes an import from one module to another, updating all type attributions.
@@ -206,7 +206,7 @@ export class ChangeImport extends Recipe {
                     this.transformedImport = true;
                     return produce(imp, draft => {
                         if (draft.moduleSpecifier) {
-                            const literal = draft.moduleSpecifier.element as WritableDraft<J.Literal>;
+                            const literal = draft.moduleSpecifier.element as Draft<J.Literal>;
                             literal.value = newModule;
                             // Update valueSource to preserve quote style
                             const originalSource = literal.valueSource || `"${oldModule}"`;
@@ -217,7 +217,7 @@ export class ChangeImport extends Recipe {
                         if (newMember !== oldMember && oldMember !== 'default' && oldMember !== '*') {
                             const importClause = draft.importClause;
                             if (importClause?.namedBindings?.kind === JS.Kind.NamedImports) {
-                                const namedImports = importClause.namedBindings as WritableDraft<JS.NamedImports>;
+                                const namedImports = importClause.namedBindings as Draft<JS.NamedImports>;
                                 for (const elem of namedImports.elements.elements) {
                                     const specifier = elem.element;
                                     if (specifier.specifier.kind === J.Kind.Identifier &&
@@ -241,7 +241,7 @@ export class ChangeImport extends Recipe {
                     if (!importClause?.namedBindings) return;
                     if (importClause.namedBindings.kind !== JS.Kind.NamedImports) return;
 
-                    const namedImports = importClause.namedBindings as WritableDraft<JS.NamedImports>;
+                    const namedImports = importClause.namedBindings as Draft<JS.NamedImports>;
                     const elements = namedImports.elements.elements;
                     const filteredElements = elements.filter(elem => {
                         const specifier = elem.element;

package/src/javascript/recipes/order-imports.ts

@@ -19,7 +19,7 @@ import {produceAsync, TreeVisitor} from "../../visitor";
 import {ExecutionContext} from "../../execution";
 import {JavaScriptVisitor, JS} from "../index";
 import {J} from "../../java";
-import {Draft, produce} from "immer";
+import {create as produce, Draft} from "mutative";
 import {SpacesStyle, styleFromSourceFile, StyleKind} from "../style";
 
 /**

package/src/javascript/templating/engine.ts

@@ -16,7 +16,7 @@
 import {Cursor, isTree, produceAsync, Tree, updateIfChanged} from '../..';
 import {emptySpace, J, Statement, Type} from '../../java';
 import {Any, Capture, JavaScriptParser, JavaScriptVisitor, JS} from '..';
-import {produce} from 'immer';
+import {create as produce} from 'mutative';
 import {CaptureMarker, PlaceholderUtils, WRAPPER_FUNCTION_NAME} from './utils';
 import {CAPTURE_NAME_SYMBOL, CAPTURE_TYPE_SYMBOL, CaptureImpl, CaptureValue, RAW_CODE_SYMBOL, RawCode} from './capture';
 import {PlaceholderReplacementVisitor} from './placeholder-replacement';

package/src/javascript/templating/index.ts

@@ -66,3 +66,8 @@ export {
     TemplateBuilder,
     template
 } from './template';
+
+// Export engine utilities (for testing)
+export {
+    clearTemplateCache
+} from './engine';

package/src/javascript/templating/placeholder-replacement.ts

@@ -17,7 +17,7 @@ import {Cursor, isTree} from '../..';
 import {J} from '../../java';
 import {JS} from '..';
 import {JavaScriptVisitor} from '../visitor';
-import {produce} from 'immer';
+import {create as produce} from 'mutative';
 import {PlaceholderUtils} from './utils';
 import {CaptureImpl, TemplateParamImpl, CaptureValue, CAPTURE_NAME_SYMBOL} from './capture';
 import {Parameter} from './types';
@@ -260,7 +260,7 @@ export class PlaceholderReplacementVisitor extends JavaScriptVisitor<any> {
                                         newElements.push(produce(item, draft => {
                                             if (i === 0 && draft.element) {
                                                 // Merge the placeholder's prefix with the first item's prefix
-                                                // Modify prefix directly without nested produce to avoid immer issues
+                                                // Modify prefix directly within the draft
                                                 draft.element.prefix = this.mergePrefix(draft.element.prefix, element.prefix);
                                             }
                                             // Keep all other wrapper properties (including markers with Semicolon)

package/src/javascript/type-mapping.ts

@@ -15,14 +15,8 @@
  */
 import ts from "typescript";
 import {Type} from "../java";
-import {immerable} from "immer";
 import FUNCTION_TYPE_NAME = Type.FUNCTION_TYPE_NAME;
 
-// Helper class to create Type objects that immer won't traverse
-class NonDraftableType {
-    [immerable] = false;
-}
-
 export class JavaScriptTypeMapping {
     // Primary cache: Use type signatures (preferring type.id) as cache keys
     // TypeScript assigns stable IDs to all types, so we don't need secondary caches
@@ -180,7 +174,7 @@ export class JavaScriptTypeMapping {
                             }
 
                             // Create the parameterized type wrapper
-                            const parameterized = Object.assign(new NonDraftableType(), {
+                            const parameterized = {
                                 kind: Type.Kind.Parameterized,
                                 type: classType,
                                 typeParameters: typeParameters,
@@ -188,7 +182,7 @@ export class JavaScriptTypeMapping {
                                 toJSON: function () {
                                     return Type.signature(this);
                                 }
-                            }) as Type.Parameterized;
+                            } as Type.Parameterized;
 
                             // Cache the parameterized type
                             this.typeCache.set(signature, parameterized);
@@ -418,7 +412,7 @@ export class JavaScriptTypeMapping {
                     if (ts.isStringLiteral(importDecl.moduleSpecifier)) {
                         const moduleSpecifier = importDecl.moduleSpecifier.text;
                         // Create a Type.Class representing the module
-                        ownerType = Object.assign(new NonDraftableType(), {
+                        ownerType = {
                             kind: Type.Kind.Class,
                             flags: 0,
                             classKind: Type.Class.Kind.Interface,
@@ -431,7 +425,7 @@ export class JavaScriptTypeMapping {
                             toJSON: function () {
                                 return Type.signature(this);
                             }
-                        }) as Type.Class;
+                        } as Type.Class;
                     }
                 }
             }
@@ -461,7 +455,7 @@ export class JavaScriptTypeMapping {
                                     // Store the module as the owningClass for now
                                     // (This is a bit of a hack, but works with the current type system)
                                     if (Type.isClass(ownerType)) {
-                                        (ownerType as any).owningClass = Object.assign(new NonDraftableType(), {
+                                        (ownerType as any).owningClass = {
                                             kind: Type.Kind.Class,
                                             flags: 0,
                                             classKind: Type.Class.Kind.Interface,
@@ -474,7 +468,7 @@ export class JavaScriptTypeMapping {
                                             toJSON: function () {
                                                 return Type.signature(this);
                                             }
-                                        }) as Type.Class;
+                                        } as Type.Class;
                                     }
                                 }
                             }
@@ -485,7 +479,7 @@ export class JavaScriptTypeMapping {
         }
 
         // Create the Type.Variable
-        const variable = Object.assign(new NonDraftableType(), {
+        const variable = {
             kind: Type.Kind.Variable,
             name: actualSymbol.getName(),
             owner: ownerType,
@@ -494,7 +488,7 @@ export class JavaScriptTypeMapping {
             toJSON: function () {
                 return Type.signature(this);
             }
-        }) as Type.Variable;
+        } as Type.Variable;
 
         return variable;
     }
@@ -593,7 +587,7 @@ export class JavaScriptTypeMapping {
         }
 
         // Create the Type.Method object
-        const method = Object.assign(new NonDraftableType(), {
+        const method = {
             kind: Type.Kind.Method,
             flags: 0, // FIXME - determine flags
             declaringType: declaringType,
@@ -608,7 +602,7 @@ export class JavaScriptTypeMapping {
             toJSON: function () {
                 return Type.signature(this);
             }
-        }) as Type.Method;
+        } as Type.Method;
 
         this.methodCache.set(cacheKey, method);
         return method;
@@ -1062,7 +1056,7 @@ export class JavaScriptTypeMapping {
         }
 
         // Create empty class type shell (no members yet to avoid recursion)
-        return Object.assign(new NonDraftableType(), {
+        return {
             kind: Type.Kind.Class,
             flags: 0, // TODO - determine flags
             classKind: classKind,
@@ -1075,7 +1069,7 @@ export class JavaScriptTypeMapping {
             toJSON: function () {
                 return Type.signature(this);
             }
-        }) as Type.Class;
+        } as Type.Class;
     }
 
     /**
@@ -1191,7 +1185,7 @@ export class JavaScriptTypeMapping {
             } else {
                 // Create Type.Variable for fields/properties
                 const propType = this.checker.getTypeOfSymbolAtLocation(prop, declaration);
-                const variable: Type.Variable = Object.assign(new NonDraftableType(), {
+                const variable: Type.Variable = {
                     kind: Type.Kind.Variable,
                     name: prop.getName(),
                     owner: classType,  // Cyclic reference to the containing class (already in cache)
@@ -1200,7 +1194,7 @@ export class JavaScriptTypeMapping {
                     toJSON: function () {
                         return Type.signature(this);
                     }
-                }) as Type.Variable;
+                } as Type.Variable;
                 classType.members.push(variable);
             }
         }
@@ -1261,10 +1255,10 @@ export class JavaScriptTypeMapping {
      */
     private createUnionType(unionType: ts.UnionType, cacheKey: string | number): Type.Union {
         // Shell-cache FIRST to prevent infinite recursion (before resolving constituent types)
-        const union = Object.assign(new NonDraftableType(), {
+        const union = {
             kind: Type.Kind.Union,
             bounds: []
-        }) as Type.Union;
+        } as Type.Union;
 
         this.typeCache.set(cacheKey, union);
 
@@ -1286,10 +1280,10 @@ export class JavaScriptTypeMapping {
      */
     private createIntersectionType(intersectionType: ts.IntersectionType, cacheKey: string | number): Type.Intersection {
         // Shell-cache FIRST to prevent infinite recursion (before resolving constituent types)
-        const intersection = Object.assign(new NonDraftableType(), {
+        const intersection = {
             kind: Type.Kind.Intersection,
             bounds: []
-        }) as Type.Intersection;
+        } as Type.Intersection;
 
         this.typeCache.set(cacheKey, intersection);
 
@@ -1315,12 +1309,12 @@ export class JavaScriptTypeMapping {
         const name = symbol ? symbol.getName() : '?';
 
         // Shell-cache: Create stub, cache it, then populate (prevents cycles)
-        const gtv = Object.assign(new NonDraftableType(), {
+        const gtv = {
             kind: Type.Kind.GenericTypeVariable,
             name: name,
             variance: Type.GenericTypeVariable.Variance.Invariant,
             bounds: []
-        }) as Type.GenericTypeVariable;
+        } as Type.GenericTypeVariable;
 
         this.typeCache.set(cacheKey, gtv);
 
@@ -1350,7 +1344,7 @@ export class JavaScriptTypeMapping {
      * The shell will be populated later to handle circular references.
      */
     private createEmptyFunctionType(): Type.Class {
-        return Object.assign(new NonDraftableType(), {
+        return {
             kind: Type.Kind.Class,
             flags: 0,
             classKind: Type.Class.Kind.Interface,
@@ -1363,7 +1357,7 @@ export class JavaScriptTypeMapping {
             toJSON: function () {
                 return Type.signature(this);
             }
-        }) as Type.Class;
+        } as Type.Class;
     }
 
     /**
@@ -1394,27 +1388,27 @@ export class JavaScriptTypeMapping {
         const typeParameters: Type[] = [];
 
         // Return type parameter (covariant)
-        typeParameters.push(Object.assign(new NonDraftableType(), {
+        typeParameters.push({
             kind: Type.Kind.GenericTypeVariable,
             name: 'R',
             variance: Type.GenericTypeVariable.Variance.Covariant,
             bounds: [returnType]
-        }) as Type.GenericTypeVariable);
+        } as Type.GenericTypeVariable);
 
         // Parameter type variables (contravariant)
         parameterTypes.forEach((paramType, index) => {
-            typeParameters.push(Object.assign(new NonDraftableType(), {
+            typeParameters.push({
                 kind: Type.Kind.GenericTypeVariable,
                 name: `P${index + 1}`,
                 variance: Type.GenericTypeVariable.Variance.Contravariant,
                 bounds: [paramType]
-            }) as Type.GenericTypeVariable);
+            } as Type.GenericTypeVariable);
         });
 
         functionClass.typeParameters = typeParameters;
 
         // Create the apply() method
-        const applyMethod = Object.assign(new NonDraftableType(), {
+        const applyMethod = {
             kind: Type.Kind.Method,
             flags: 0,
             declaringType: functionClass,
@@ -1429,7 +1423,7 @@ export class JavaScriptTypeMapping {
             toJSON: function () {
                 return Type.signature(this);
             }
-        }) as Type.Method;
+        } as Type.Method;
 
         // Add the apply method to the function class
         functionClass.methods.push(applyMethod);

package/src/javascript/visitor.ts

@@ -17,9 +17,9 @@
  */
 import {mapAsync, updateIfChanged} from "../util";
 import {Cursor, SourceFile} from "../tree";
-import {ValidImmerRecipeReturnType} from "../visitor";
+import {ValidRecipeReturnType} from "../visitor";
 import {Expression, J, Type, JavaVisitor, NameTree, Statement, TypedTree} from "../java";
-import {createDraft, Draft, finishDraft} from "immer";
+import {create, Draft} from "mutative";
 import {isJavaScript, JS, JSX} from "./tree";
 import ComputedPropertyName = JS.ComputedPropertyName;
 
@@ -58,16 +58,16 @@ export class JavaScriptVisitor<P> extends JavaVisitor<P> {
         before: J2,
         p: P,
         recipe?: (draft: Draft<J2>) =>
-            ValidImmerRecipeReturnType<Draft<J2>> |
-            PromiseLike<ValidImmerRecipeReturnType<Draft<J2>>>
+            ValidRecipeReturnType<Draft<J2>> |
+            PromiseLike<ValidRecipeReturnType<Draft<J2>>>
     ): Promise<J2> {
-        const draft: Draft<J2> = createDraft(before!);
+        const [draft, finishDraft] = create(before!);
         (draft as Draft<J>).prefix = await this.visitSpace(before!.prefix, p);
         (draft as Draft<J>).markers = await this.visitMarkers(before!.markers, p);
         if (recipe) {
             await recipe(draft);
         }
-        return finishDraft(draft) as J2;
+        return finishDraft() as J2;
     }
 
     protected async visitAlias(alias: JS.Alias, p: P): Promise<J | undefined> {