@openrewrite/recipes-nodejs 0.52.0-20261009-102010 → 0.52.1

package/src/migrate/hpagent/replace-hpagent.ts

@@ -4,25 +4,57 @@
  * Moderne Proprietary. Only for use by Moderne customers under the terms of a commercial contract.
  */
 
-import {emptyMarkers, ExecutionContext, Option, randomId, Recipe, TreeVisitor} from "@openrewrite/rewrite";
-import {isIdentifier, J, rightPadded, space} from "@openrewrite/rewrite/java";
-import {compilationUnitOf, declarationsOf, JavaScriptVisitor, JS, maybeRebind, maybeUnbind, namesDeclaredIn} from "@openrewrite/rewrite/javascript";
-import {requiredModule} from "../module-bindings";
+import {Cursor, emptyMarkers, ExecutionContext, findMarker, Option, randomId, Recipe, TreePrinters, TreeVisitor} from "@openrewrite/rewrite";
+import {emptySpace, isIdentifier, J, rightPadded, space} from "@openrewrite/rewrite/java";
 import {
-    bindingsOf,
+    autoFormat,
+    bindingNames,
+    compilationUnitOf,
+    declarationsOf,
+    deconflict,
+    isReference,
+    JavaScriptParser,
+    JavaScriptVisitor,
+    JS,
+    maybeRebind,
+    maybeUnbind,
+    namesUsedIn,
+    StyleKind
+} from "@openrewrite/rewrite/javascript";
+import {detectCodeStyle} from "../code-style";
+import {bindingsOf, importModule, requiredModule} from "../module-bindings";
+import {
+    ADAPTED_TYPES,
+    ADAPTER_FUNCTION,
+    ADAPTER_TYPE,
+    adapterSource,
+    adapterTypeSource,
+    builtinAgentModule,
+    builtinAgentType,
     classifyOption,
+    constructionArgument,
+    emptyHpagentBindings,
+    GeneratedDeclaration,
     HPAGENT_CLASSES,
     HPAGENT_MODULES,
+    hpagentBindings,
+    HpagentBindings,
+    inTypePosition,
+    isHpagentRequire,
     isKnownProxyRequestOptions,
+    isMockCall,
     isObjectLiteral,
-    isModuleScoped,
-    spreadIsPlainAgentOptions,
+    isValueUse,
     ModuleBindings,
     objectMembers,
     propertyName,
+    REQUEST_TYPE,
+    resolvesToBinding,
+    spiedClass,
+    spreadIsPlainAgentOptions,
+    stringLiteral,
     TARGET_CLASS,
     TARGET_MODULE,
-    targetTypeReference,
 } from "./hpagent-support";
 
 /**
@@ -36,43 +68,25 @@ interface Rewrite {
     literal: J.NewClass;
 }
 
-/** The names a file's top-level `require`s of hpagent bind, whichever destructuring shape they use. */
-function requireBoundNames(cu: JS.CompilationUnit): Set<string> {
-    const names = new Set<string>();
-    for (const padded of cu.statements) {
-        for (const decl of declarationsOf(padded.element)) {
-            for (const v of decl.variables) {
-                const variable = v.element;
-                if (!HPAGENT_MODULES.has(requiredModule(variable.initializer?.element) ?? '')) continue;
-                for (const name of boundNames(variable.name as J)) names.add(name);
-            }
-        }
-    }
-    return names;
-}
-
-/** The local names a `require`'s binding target introduces. */
-function boundNames(target: J): string[] {
-    if (isIdentifier(target)) return [target.simpleName];
-    if (target.kind !== JS.Kind.ObjectBindingPattern) return [];
-    return (target as JS.ObjectBindingPattern).bindings.elements.flatMap(padded => {
-        const binding = padded.element as J;
-        if (isIdentifier(binding)) return [binding.simpleName];
-        if (binding.kind !== JS.Kind.BindingElement) return [];
-        const name = (binding as JS.BindingElement).name as J;
-        return isIdentifier(name) ? [name.simpleName] : [];
-    });
+/** The local name a binding pattern element introduces. */
+function boundLocal(binding: J): string | undefined {
+    if (isIdentifier(binding)) return binding.simpleName;
+    if (binding.kind !== JS.Kind.BindingElement) return undefined;
+    const name = (binding as JS.BindingElement).name as J;
+    return isIdentifier(name) ? name.simpleName : undefined;
 }
 
 /**
  * Renames a `require`'s destructured bindings to the names the migration gives them. A shorthand
  * `{HttpProxyAgent}` becomes `{HttpsProxyAgent}`; one that already names a property — `{X: local}` —
- * keeps its local name and takes the new property.
+ * keeps its local name and takes the new property. A binding folded into another is dropped.
  */
-function renameBindings(target: J, targetLocals: ReadonlyMap<string, string>): J {
+function renameBindings(target: J, targetLocals: ReadonlyMap<string, string>, merged: ReadonlySet<string>): J {
     if (target.kind !== JS.Kind.ObjectBindingPattern) return target;
     const pattern = target as JS.ObjectBindingPattern;
-    const elements = pattern.bindings.elements.map(padded => {
+    const original = pattern.bindings.elements;
+    const kept = original.filter(padded => !merged.has(boundLocal(padded.element as J) ?? ''));
+    const elements = kept.map(padded => {
         const binding = padded.element as J;
         if (isIdentifier(binding)) {
             const renamed = targetLocals.get(binding.simpleName);
@@ -92,19 +106,76 @@ function renameBindings(target: J, targetLocals: ReadonlyMap<string, string>): J
         const name = element.name as J;
         if (!isIdentifier(name)) return padded;
         const renamed = targetLocals.get(name.simpleName);
-        return renamed && renamed !== name.simpleName
-            ? {...padded, element: {...element, name: {...name, simpleName: renamed}} as J}
-            : padded;
+        if (!renamed || renamed === name.simpleName) return padded;
+        if (renamed === TARGET_CLASS) return {...padded, element: {...element, name: {...name, simpleName: renamed}} as J};
+        // A deconflicted name can't be shorthand, so it reads the class off as `{HttpsProxyAgent: renamed}`.
+        return {
+            ...padded,
+            element: {
+                ...element,
+                propertyName: rightPadded({...name, id: randomId(), simpleName: TARGET_CLASS} as J.Identifier, emptySpace),
+                name: {...name, prefix: space(' '), simpleName: renamed}
+            } as J
+        };
     });
+    // The padding after the last element holds the space before `}`, so the new last element takes it.
+    if (elements.length > 0 && kept[kept.length - 1] !== original[original.length - 1]) {
+        elements[elements.length - 1] = {...elements[elements.length - 1], after: original[original.length - 1].after};
+    }
     return {...pattern, bindings: {...pattern.bindings, elements}} as J;
 }
 
+function retargeted(literal: J.Literal): J.Literal {
+    const quote = (literal.valueSource ?? "'").charAt(0);
+    return {...literal, value: TARGET_MODULE, valueSource: `${quote}${TARGET_MODULE}${quote}`};
+}
+
+/** `require('hpagent')` naming the new module, together with a `typeof import('hpagent')` it is cast to. */
+function movedRequireCall(e: J): J {
+    if (e.kind === JS.Kind.As) {
+        const as = e as JS.As;
+        return {...as, left: {...as.left, element: movedRequireCall(as.left.element)}, right: movedImportType(as.right)} as J;
+    }
+    const call = e as J.MethodInvocation;
+    const specifier = call.arguments.elements[0];
+    return {...call, arguments: {...call.arguments, elements: [{...specifier, element: retargeted(specifier.element as J.Literal)}]}} as J.MethodInvocation;
+}
+
+function movedImportType(type: J): J {
+    if (type.kind !== JS.Kind.ImportType) return type;
+    const importType = type as JS.ImportType;
+    const elements = importType.argumentAndAttributes.elements.map(padded => {
+        const argument = padded.element;
+        if (argument.kind !== JS.Kind.LiteralType) return padded;
+        const literal = (argument as JS.LiteralType).literal as J.Literal;
+        return HPAGENT_MODULES.has(stringLiteral(literal) ?? '')
+            ? {...padded, element: {...argument, literal: retargeted(literal)} as J}
+            : padded;
+    });
+    return {...importType, argumentAndAttributes: {...importType.argumentAndAttributes, elements}} as J;
+}
+
 /** What a type arm denotes, for spotting two arms that say the same thing. */
 function typeKey(type: J): string | undefined {
     if (isIdentifier(type)) return type.simpleName;
+    if (type.kind === J.Kind.FieldAccess) {
+        const access = type as J.FieldAccess;
+        return isIdentifier(access.target) ? `${access.target.simpleName}.${access.name.element.simpleName}` : undefined;
+    }
+    if (type.kind === JS.Kind.ImportType) {
+        const importType = type as JS.ImportType;
+        const module = importType.argumentAndAttributes.elements[0]?.element as JS.LiteralType | undefined;
+        const name = importType.qualifier?.element;
+        return module?.kind === JS.Kind.LiteralType && name && isIdentifier(name)
+            ? `import(${stringLiteral(module.literal)}).${name.simpleName}`
+            : undefined;
+    }
     if (type.kind !== J.Kind.ParameterizedType) return undefined;
     const clazz = (type as J.ParameterizedType).class as J;
-    return isIdentifier(clazz) ? `${clazz.simpleName}<>` : undefined;
+    if (isIdentifier(clazz)) return `${clazz.simpleName}<>`;
+    if (clazz.kind !== J.Kind.FieldAccess) return undefined;
+    const access = clazz as J.FieldAccess;
+    return isIdentifier(access.target) ? `${access.target.simpleName}.${access.name.element.simpleName}<>` : undefined;
 }
 
 /**
@@ -160,7 +231,7 @@ function isJavaScript(sourcePath: string): boolean {
 }
 
 /** `proxy ? construction : undefined`, built directly so the construction keeps its layout. */
-function whenDefined(proxy: J, construction: J.NewClass): J.Ternary {
+function whenDefined(proxy: J, construction: J): J.Ternary {
     const padded = <T extends J>(element: T): J.LeftPadded<T> =>
         ({kind: J.Kind.LeftPadded, before: space(' '), element, markers: emptyMarkers});
     const undefinedValue: J.Identifier = {
@@ -172,7 +243,7 @@ function whenDefined(proxy: J, construction: J.NewClass): J.Ternary {
         prefix: construction.prefix,
         markers: emptyMarkers,
         condition: {...proxy, id: randomId(), prefix: space('')} as J,
-        truePart: padded({...construction, prefix: space(' ')} as J.NewClass),
+        truePart: padded({...construction, prefix: space(' ')} as J),
         falsePart: padded(undefinedValue),
     } as J.Ternary;
 }
@@ -182,6 +253,61 @@ function paddedMembers(literal: J.NewClass): J.RightPadded<J>[] {
     return (literal.body?.statements ?? []).filter(padded => padded.element.kind !== J.Kind.Empty) as J.RightPadded<J>[];
 }
 
+/**
+ * A builtin's specifier for a type query. The bare name unless the file already writes `node:`, since
+ * `@types/node` declared the prefixed names only from 16, after hpagent's Node 14 floor.
+ */
+function builtinSpecifier(cu: JS.CompilationUnit, module: string): string {
+    const prefixed = cu.statements.some(padded => {
+        const statement = padded.element;
+        const specifier = statement?.kind === JS.Kind.Import
+            ? importModule(statement as JS.Import)
+            : declarationsOf(statement).map(d => d.variables.map(v => requiredModule(v.element.initializer?.element)).find(Boolean)).find(Boolean);
+        return specifier?.startsWith('node:');
+    });
+    return prefixed ? `node:${module}` : module;
+}
+
+/** One of hpagent's option types, which the adapter's own types stand in for. */
+function isOptionType(member: string): boolean {
+    return ADAPTED_TYPES.has(member) || member === 'ProxyAgentRequestOptions';
+}
+
+/** `declare module 'hpagent' {...}`, which declared types for the module the migration drops. */
+function isAmbientHpagent(statement: J | undefined): boolean {
+    if (statement?.kind !== JS.Kind.NamespaceDeclaration) return false;
+    const declaration = statement as JS.NamespaceDeclaration;
+    return declaration.keywordType.element === JS.NamespaceDeclaration.KeywordType.Module &&
+        HPAGENT_MODULES.has(stringLiteral(declaration.name.element) ?? '');
+}
+
+/** `ConstructorParameters<typeof X>[0]`, the options a constructor takes; the `typeof` operand, if it is that. */
+function constructorOptionsOf(type: JS.IndexedAccessType): J | undefined {
+    const index = (type.indexType as JS.IndexedAccessType.IndexType).element.element;
+    if (index.kind !== JS.Kind.LiteralType || (index as JS.LiteralType).literal.kind !== J.Kind.Literal ||
+        ((index as JS.LiteralType).literal as J.Literal).value !== 0) {
+        return undefined;
+    }
+    if (type.objectType.kind !== J.Kind.ParameterizedType) return undefined;
+    const parameterized = type.objectType as J.ParameterizedType;
+    const query = parameterized.typeParameters?.elements;
+    if (!isIdentifier(parameterized.class) || parameterized.class.simpleName !== 'ConstructorParameters' ||
+        query?.length !== 1 || query[0].element.kind !== JS.Kind.TypeQuery) {
+        return undefined;
+    }
+    return (query[0].element as JS.TypeQuery).typeExpression;
+}
+
+/** The `proxy` an options literal names, if it is one. */
+function literalProxy(options: J): J | undefined {
+    if (!isObjectLiteral(options)) return undefined;
+    for (const padded of paddedMembers(options)) {
+        const option = classifyOption(padded.element);
+        if (option.kind === 'proxy') return option.value;
+    }
+    return undefined;
+}
+
 export class ReplaceHpagent extends Recipe {
     readonly name = "org.openrewrite.node.migrate.hpagent.replace-hpagent";
     readonly displayName = "Replace `hpagent` with `https-proxy-agent`";
@@ -192,21 +318,29 @@ export class ReplaceHpagent extends Recipe {
         "`https:` target, so one class serves both. `proxyRequestOptions` members move up into the options object, " +
         "where `https-proxy-agent` applies them to the connection to the proxy. hpagent accepted a missing proxy until " +
         "a request needed it, but `https-proxy-agent` reads it in the constructor, so in JavaScript a proxy that may be " +
-        "missing, such as `process.env.HTTP_PROXY`, guards the construction: `proxy ? new HttpsProxyAgent(proxy) : undefined`. " +
-        "Calls whose options aren't an object " +
-        "literal, or that set a TLS option for the destination handshake (`ca`, `rejectUnauthorized`, `cert`, ...), " +
-        "are left alone: `https-proxy-agent` would apply those to the proxy hop instead. " +
-        "`FindHpagentManualMigrations` reports every usage left behind.";
+        "missing, such as `process.env.HTTP_PROXY`, guards the construction: `proxy ? new HttpsProxyAgent(proxy) : undefined`.\n\n" +
+        "A construction that can't take the two-argument form — options that aren't an object literal, a spread " +
+        "that can't be checked, or a TLS option for the destination handshake (`ca`, `rejectUnauthorized`, `cert`, " +
+        "...), which `https-proxy-agent` would apply to the proxy hop — calls a `createProxyAgent` adapter written " +
+        "into the same file instead. It takes hpagent's options object as it was, gives the proxy hop what hpagent " +
+        "gave it, and puts every other option on the agent's per-request options, which is where hpagent's " +
+        "`https.Agent` kept them for the destination. hpagent's option types become the adapter's own " +
+        "`ProxyAgentOptions`, `ConstructorParameters<typeof HttpProxyAgent>[0]` included, and `ProxyAgentRequestOptions` " +
+        "a `ProxyRequestOptions` of its own; `instanceof` checks and type references move to the new class. A default " +
+        "import becomes a namespace import, since `https-proxy-agent` has no default export; a block's " +
+        "`const {...} = require('hpagent')`, and `({...} = require('hpagent'))` into a `let`, move like a top-level one; " +
+        "`jest.mock`/`vi.mock` and `spyOn` follow the module in a file whose hpagent bindings all moved; and a " +
+        "`declare module 'hpagent'` is deleted. `FindHpagentManualMigrations` reports every usage left behind.";
     readonly tags = ["hpagent", "https-proxy-agent"];
 
     @Option({
         displayName: "Migrate spread options",
-        description: "Also migrate options that spread another object, as in `{...shared, proxy: url}`, passing the " +
-            "spread through to the new options object. Left off by default: the spread may itself carry a " +
-            "`proxyRequestOptions`, which has to be flattened, or a TLS option for the destination handshake, which " +
-            "`https-proxy-agent` would apply to the proxy connection instead. Enable it once the spread objects in " +
-            "the codebase are known to hold plain agent options. A spread that resolves to a literal of plain " +
-            "agent options in the same file is migrated either way, since there it can be checked rather than assumed.",
+        description: "Rewrite options that spread another object, as in `{...shared, proxy: url}`, to the " +
+            "two-argument form, passing the spread through to the new options object, instead of calling the " +
+            "adapter. Left off by default: the spread may itself carry a `proxyRequestOptions`, which has to be " +
+            "flattened, or a TLS option for the destination handshake, which `https-proxy-agent` would apply to the " +
+            "proxy connection instead. A spread that resolves to a literal of plain agent options in the same file " +
+            "takes the two-argument form either way, since there it can be checked rather than assumed.",
         required: false
     })
     migrateSpreadOptions?: boolean;
@@ -218,82 +352,114 @@ export class ReplaceHpagent extends Recipe {
     async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
         const migrateSpreadOptions = this.migrateSpreadOptions ?? false;
         return new class extends JavaScriptVisitor<ExecutionContext> {
+            private found: HpagentBindings = emptyHpagentBindings();
             private bindings: ModuleBindings = new Map();
-            /** Bindings whose every construction site was rewritten, so the import can move with them. */
+            /** Bindings with no site left behind, so the import can move with them. */
             private migrated = new Set<string>();
             /** Bindings with a site left behind, which keeps their hpagent import in place. */
             private stranded = new Set<string>();
             /** What each binding is called once migrated, which the rewritten call sites have to use. */
             private targetLocals = new Map<string, string>();
-            /** Bindings a `require` introduces, which `maybeRebind` leaves alone; this visitor moves them itself. */
-            private requireBound = new Set<string>();
             /** Set for the survey pass, which only records what can move and changes nothing. */
             private surveying = false;
             /** Class bindings folded into another one, whose own binding is dropped once its sites point at that. */
             private merged = new Set<string>();
             /** Bindings that share one name after the move, and so move together or not at all. */
             private folds: string[][] = [];
-            /** Bindings named in a type position, which the move has to carry along with the calls. */
-            private typeUses = new Set<string>();
+            /** Bindings with a construction the adapter takes, any of which can name the class for it. */
+            private adapterLocals = new Set<string>();
+            /** Bindings something still names as a value; one named only in types is unbound rather than moved. */
+            private referenced = new Set<string>();
+            /** The file's own bindings of the whole `http` and `https` modules, to spell a type through. */
+            private builtinLocals = new Map<string, string>();
+            /** Type arms this rewrote, which a union may drop as duplicates of another arm. */
+            private producedTypes = new Set<string>();
+            private adapterName = ADAPTER_FUNCTION;
+            private typeName = ADAPTER_TYPE;
+            private requestTypeName = REQUEST_TYPE;
+            private adapterNeeded = false;
+            private typeNeeded = false;
+            private requestTypeNeeded = false;
+            /** Whole-module imports rewritten where they stand, which the rebinding after the visit leaves alone. */
+            private movedInPlace = new Set<string>();
 
             protected override async visitJsCompilationUnit(cu: JS.CompilationUnit, p: ExecutionContext): Promise<J | undefined> {
-                this.bindings = bindingsOf(cu, HPAGENT_MODULES);
+                // Types declared for hpagent go with it; without the module there is nothing for them to describe.
+                if (!this.surveying && cu.statements.some(padded => isAmbientHpagent(padded.element))) {
+                    cu = {...cu, statements: cu.statements.filter(padded => !isAmbientHpagent(padded.element))};
+                }
+                this.found = hpagentBindings(cu);
+                this.bindings = this.found.bindings;
                 this.migrated = new Set();
                 this.stranded = new Set();
                 this.targetLocals = new Map();
                 this.merged = new Set();
                 this.folds = [];
-                this.typeUses = new Set();
-                this.requireBound = requireBoundNames(cu);
+                this.adapterLocals = new Set();
+                this.referenced = new Set();
+                this.producedTypes = new Set();
+                this.builtinLocals = new Map();
+                this.adapterNeeded = false;
+                this.typeNeeded = false;
+                this.requestTypeNeeded = false;
+                this.movedInPlace = new Set();
                 if (this.bindings.size === 0) return cu;
                 this.planNames(cu);
+                for (const module of ['http', 'https']) {
+                    const whole = [...bindingsOf(cu, new Set([module, `node:${module}`]))].find(([, member]) => member === undefined);
+                    if (whole) this.builtinLocals.set(module, whole[0]);
+                }
+                const used = namesUsedIn(cu);
+                this.adapterName = deconflict(ADAPTER_FUNCTION, name => used.has(name));
+                this.typeName = deconflict(ADAPTER_TYPE, name => used.has(name));
+                this.requestTypeName = deconflict(REQUEST_TYPE, name => used.has(name));
 
-                // A binding moves only if every one of its constructions can: those left behind keep hpagent's
+                // A binding moves only if every one of its sites can: one left behind keeps hpagent's
                 // options-object constructor, so rewriting any site of theirs would break it. Hence a survey
                 // pass first, whose result is discarded, and only then the pass that edits.
                 this.surveying = true;
                 await super.visitJsCompilationUnit(cu, p);
                 this.surveying = false;
-                // A binding named only in a type position has no construction to migrate, but its
-                // type reference moves, so it counts as migrating for the fold below.
-                for (const local of this.typeUses) this.migrated.add(local);
+                // Every site of a binding not stranded can move, including one with no construction at all,
+                // named only as a type or by `instanceof`, or not used anywhere.
+                for (const local of this.targetLocals.keys()) this.migrated.add(local);
                 // Folded bindings end up under one name, so every one of them has to move. One left
-                // behind — a site of its own that can't migrate, or nothing to migrate at all —
-                // keeps its specifier on hpagent, and the shared name would then denote hpagent's
-                // class while the rewritten calls pass the proxy positionally. Refusing the whole
-                // fold leaves each binding as it was.
+                // behind keeps its specifier on hpagent, and the shared name would then denote hpagent's
+                // class while the rewritten calls pass the proxy positionally. Refusing the whole fold
+                // leaves each binding as it was.
                 for (const fold of this.folds) {
-                    if (fold.some(local => this.stranded.has(local) || !this.migrated.has(local))) {
+                    // A use of any member is a use of the binding they all end up as.
+                    if (fold.some(local => this.referenced.has(local))) for (const local of fold) this.referenced.add(local);
+                    if (fold.some(local => this.stranded.has(local))) {
                         for (const local of fold) this.stranded.add(local);
                     }
                 }
-                if ([...this.migrated].every(local => this.stranded.has(local))) return cu;
+                const optionTypes = [...this.bindings.values()].some(member => member !== undefined && isOptionType(member));
+                if ([...this.migrated].every(local => this.stranded.has(local)) && !optionTypes) return cu;
 
-                const result = await super.visitJsCompilationUnit(cu, p) as JS.CompilationUnit;
+                let result = await super.visitJsCompilationUnit(cu, p) as JS.CompilationUnit;
+                if (this.adapterNeeded || this.typeNeeded || this.requestTypeNeeded) result = await this.withAdapter(result, p);
                 this.rebindMigrated();
-                return this.rewriteRequires(result);
+                return result;
             }
 
             /**
-             * What each hpagent binding will be called after the move. An unaliased class binding takes the
-             * new module's own name for it; an alias, and a binding of the whole module, keep theirs. A name
-             * the file already uses would collide, so those bindings are left where they are.
+             * What each hpagent class binding will be called after the move. An unaliased class binding takes
+             * the new module's own name for it, deconflicted against the file's own; an alias, and a binding
+             * of the whole module, keep theirs.
              */
             private planNames(cu: JS.CompilationUnit): void {
-                const declared = namesDeclaredIn(cu);
+                const used = namesUsedIn(cu);
                 // Both agent classes become the one class, so a file binding both folds them together
                 // rather than colliding: `https-proxy-agent` tunnels either way and picks TLS per request.
-                const classes = [...this.bindings].filter(([, member]) => member !== undefined && HPAGENT_CLASSES.has(member));
-                const foldable = new Set(classes.filter(([local, member]) => local === member).map(([local]) => local));
+                const movable = [...this.bindings].filter(([, member]) => member === undefined || HPAGENT_CLASSES.has(member));
+                const foldable = new Set(movable.filter(([local, member]) => local === member).map(([local]) => local));
 
+                const targetClass = deconflict(TARGET_CLASS, name => used.has(name) && !foldable.has(name));
                 const targets = new Map<string, string[]>();
-                for (const [local, member] of this.bindings) {
-                    const target = member !== undefined && local === member ? TARGET_CLASS : local;
-                    // A name the file uses for something else leaves this binding where it is.
-                    if (target !== local && declared.has(target) && !foldable.has(target)) {
-                        this.stranded.add(local);
-                        continue;
-                    }
+                for (const [local, member] of movable) {
+                    // A name assigned into a `let` keeps it, since the declaration and every use would otherwise have to follow.
+                    const target = member !== undefined && local === member && !this.found.assigned.has(local) ? targetClass : local;
                     this.targetLocals.set(local, target);
                     targets.set(target, [...(targets.get(target) ?? []), local]);
                 }
@@ -314,27 +480,86 @@ export class ReplaceHpagent extends Recipe {
             /**
              * Moves the imports of bindings whose every site was rewritten. A named binding of either hpagent
              * class becomes `https-proxy-agent`'s `HttpsProxyAgent`; a whole-module binding moves module and
-             * keeps its name, since the new module exports that same class name.
+             * keeps its name, since the new module exports that same class name. hpagent's option types are
+             * dropped once the adapter's type has taken every reference to them.
              */
             private rebindMigrated(): void {
                 for (const local of this.migrated) {
-                    if (this.stranded.has(local) || this.requireBound.has(local)) continue;
+                    if (this.stranded.has(local) || this.found.requireBound.has(local) || this.movedInPlace.has(local)) continue;
                     const member = this.bindings.get(local);
                     if (this.merged.has(local)) {
                         // Its sites now name the surviving binding, so this specifier is unused.
                         maybeUnbind(this, {module: 'hpagent', member});
                         continue;
                     }
+                    if (!this.referenced.has(local)) {
+                        // Named only in types, which are builtin agents now.
+                        maybeUnbind(this, member === undefined ? {module: 'hpagent'} : {module: 'hpagent', member});
+                        continue;
+                    }
                     if (member === undefined) {
                         maybeRebind(this, {from: {module: 'hpagent'}, to: {module: TARGET_MODULE}});
                     } else {
+                        const target = this.targetLocals.get(local)!;
                         maybeRebind(this, {
                             from: {module: 'hpagent', member},
                             // An unaliased `HttpProxyAgent` takes the new member's name; an alias the file chose survives.
-                            to: {module: TARGET_MODULE, member: TARGET_CLASS, ...(local === member ? {} : {alias: local})}
+                            to: {module: TARGET_MODULE, member: TARGET_CLASS, ...(target === TARGET_CLASS ? {} : {alias: target})}
                         });
                     }
                 }
+                for (const [local, member] of this.bindings) {
+                    if (member !== undefined && isOptionType(member) && !this.found.requireBound.has(local)) {
+                        maybeUnbind(this, {module: 'hpagent', member});
+                    }
+                }
+            }
+
+            /**
+             * `import hpagent from 'hpagent'` or `import * as hpagent from 'hpagent'`, rewritten where it stands to
+             * `import * as hpagent from 'https-proxy-agent'`: the new module has no default export, so the whole
+             * module is its namespace, and rewriting in place keeps the import where and how the file wrote it.
+             */
+            protected override async visitImportDeclaration(jsImport: JS.Import, p: ExecutionContext): Promise<J | undefined> {
+                const imp = await super.visitImportDeclaration(jsImport, p) as JS.Import;
+                const clause = imp?.importClause;
+                if (this.surveying || imp?.kind !== JS.Kind.Import || !clause || clause.typeOnly ||
+                    !HPAGENT_MODULES.has(importModule(imp) ?? '')) {
+                    return imp;
+                }
+                const named = clause.namedBindings;
+                const namespace = named?.kind === JS.Kind.Alias ? named as JS.Alias : undefined;
+                const defaultName = !named ? clause.name?.element : undefined;
+                const local = defaultName ?? (!clause.name && namespace && isIdentifier(namespace.alias) ? namespace.alias : undefined);
+                if (!local || !this.migrated.has(local.simpleName) || this.stranded.has(local.simpleName) ||
+                    !this.referenced.has(local.simpleName)) {
+                    return imp;
+                }
+                this.movedInPlace.add(local.simpleName);
+                const moved = {...imp, moduleSpecifier: {...imp.moduleSpecifier!, element: retargeted(imp.moduleSpecifier!.element as J.Literal)}};
+                if (!defaultName) return moved;
+                const star = {kind: J.Kind.Identifier, id: randomId(), prefix: emptySpace, markers: emptyMarkers, annotations: [], simpleName: '*'};
+                const alias = {
+                    kind: JS.Kind.Alias, id: randomId(), prefix: defaultName.prefix, markers: emptyMarkers,
+                    propertyName: rightPadded(star, space(' ')), alias: {...defaultName, prefix: space(' ')}
+                };
+                return {
+                    ...moved,
+                    importClause: {...clause, name: undefined, namedBindings: alias},
+                    // The space before `from` sat after the default name.
+                    moduleSpecifier: {...moved.moduleSpecifier, before: clause.name!.after}
+                } as unknown as JS.Import;
+            }
+
+            /** Whether `name` here is a binding of a whole hpagent module rather than something nearer. */
+            private isWholeModule(name: string): boolean {
+                return this.bindings.has(name) && this.bindings.get(name) === undefined && resolvesToBinding(this.cursor, name, this.found);
+            }
+
+            /** The hpagent class binding `name` is here, or undefined. */
+            private isClass(name: string): boolean {
+                const member = this.bindings.get(name);
+                return member !== undefined && HPAGENT_CLASSES.has(member) && resolvesToBinding(this.cursor, name, this.found);
             }
 
             override async visitNewClass(newClass: J.NewClass, p: ExecutionContext): Promise<J | undefined> {
@@ -344,90 +569,255 @@ export class ReplaceHpagent extends Recipe {
                 if (!site) return n;
 
                 const rewrite = this.rewriteOf(n);
+                const adaptable = !rewrite && constructionArgument(n) !== undefined;
                 if (this.surveying) {
-                    (rewrite ? this.migrated : this.stranded).add(site.local);
+                    (rewrite || adaptable ? this.migrated : this.stranded).add(site.local);
+                    if (rewrite || adaptable) this.referenced.add(site.local);
+                    if (adaptable) this.adapterLocals.add(site.local);
                     return n;
                 }
-                if (!rewrite || this.stranded.has(site.local)) return n;
-                const migrated = this.applyRewrite(n, site, rewrite);
+                if (this.stranded.has(site.local) || !(rewrite || adaptable)) return n;
+                const migrated = rewrite ? this.applyRewrite(n, site, rewrite) : this.adapterCall(n);
+                const proxy = rewrite ? rewrite.proxy : literalProxy(constructionArgument(n)!);
                 // Constructing with a missing proxy used to succeed and now throws, as when a module builds its
                 // agent from an environment variable a test run doesn't set, so the construction is skipped then.
-                return isJavaScript(compilationUnitOf(this)!.sourcePath) && !alwaysDefined(rewrite.proxy) && readsOnly(rewrite.proxy)
-                    ? whenDefined(rewrite.proxy, migrated)
+                return proxy && isJavaScript(compilationUnitOf(this)!.sourcePath) && !alwaysDefined(proxy) && readsOnly(proxy)
+                    ? whenDefined(proxy, migrated)
                     : migrated;
             }
 
+            /** `createProxyAgent(options)` in place of `new HttpsProxyAgent(options)`, with the arguments as written. */
+            private adapterCall(n: J.NewClass): J.MethodInvocation {
+                this.adapterNeeded = true;
+                this.typeNeeded = true;
+                return {
+                    kind: J.Kind.MethodInvocation,
+                    id: randomId(),
+                    prefix: n.prefix,
+                    markers: emptyMarkers,
+                    name: {
+                        kind: J.Kind.Identifier, id: randomId(), prefix: emptySpace, markers: emptyMarkers,
+                        annotations: [], simpleName: this.adapterName
+                    } as J.Identifier,
+                    arguments: n.arguments,
+                } as unknown as J.MethodInvocation;
+            }
+
+            /** `x instanceof HttpProxyAgent`, which tests for the one class both hpagent classes became. */
+            override async visitInstanceOf(instanceOf: J.InstanceOf, p: ExecutionContext): Promise<J | undefined> {
+                const i = await super.visitInstanceOf(instanceOf, p) as J.InstanceOf;
+                if (i?.kind !== J.Kind.InstanceOf) return i;
+                const site = this.hpagentSite(i.class);
+                if (!site) return i;
+                if (this.surveying) {
+                    this.referenced.add(site.local);
+                    return i;
+                }
+                return this.stranded.has(site.local) ? i : {...i, class: this.migratedCallee(i.class, site)} as J.InstanceOf;
+            }
+
+            override async visitIdentifier(identifier: J.Identifier, p: ExecutionContext): Promise<J | undefined> {
+                const id = await super.visitIdentifier(identifier, p) as J.Identifier;
+                if (id?.kind !== J.Kind.Identifier || !this.bindings.has(id.simpleName)) return id;
+                if (this.found.assignmentTargets.has(identifier.id)) return id;
+                if (!isReference(this.cursor, identifier) || !resolvesToBinding(this.cursor, id.simpleName, this.found)) return id;
+                const member = this.bindings.get(id.simpleName);
+                if (member !== undefined && isOptionType(member)) return this.optionType(id);
+                if (member !== undefined && !HPAGENT_CLASSES.has(member)) return id;
+                if (member !== undefined && (inTypePosition(this.cursor) || this.found.typeOnly.has(id.simpleName))) {
+                    return this.typeReference(id, id.simpleName);
+                }
+                if (member === undefined && this.isSpiedModule(id)) {
+                    if (this.surveying) this.referenced.add(id.simpleName);
+                    return id;
+                }
+                // A class or module passed around as a value is constructed somewhere this can't see.
+                if (this.surveying && isValueUse(this.cursor)) this.stranded.add(id.simpleName);
+                return id;
+            }
+
+            /** The adapter's type for one of hpagent's option types, at a site that names it. */
+            private optionType(type: J): J {
+                if (this.surveying) return type;
+                const request = type.kind === J.Kind.FieldAccess
+                    ? (type as J.FieldAccess).name.element.simpleName === 'ProxyAgentRequestOptions'
+                    : this.bindings.get((type as J.Identifier).simpleName) === 'ProxyAgentRequestOptions';
+                if (request) this.requestTypeNeeded = true;
+                else this.typeNeeded = true;
+                return {
+                    kind: J.Kind.Identifier, id: randomId(), prefix: type.prefix, markers: emptyMarkers,
+                    annotations: [], simpleName: request ? this.requestTypeName : this.typeName
+                } as J.Identifier;
+            }
+
+            /** Whether `id` is the module `jest.spyOn(module, 'HttpsProxyAgent')` reads a class off. */
+            private isSpiedModule(id: J.Identifier): boolean {
+                const parent = this.cursor.parentTree()?.value as J | undefined;
+                return parent?.kind === J.Kind.MethodInvocation && spiedClass(parent as J.MethodInvocation) !== undefined &&
+                    (parent as J.MethodInvocation).arguments.elements[0]?.element === this.cursor.value;
+            }
+
+            /** `hpagent.HttpProxyAgent` or `hpagent.HttpsProxyAgentOptions` through a binding of the whole module. */
+            override async visitFieldAccess(fieldAccess: J.FieldAccess, p: ExecutionContext): Promise<J | undefined> {
+                const fa = await super.visitFieldAccess(fieldAccess, p) as J.FieldAccess;
+                if (fa?.kind !== J.Kind.FieldAccess || !isIdentifier(fa.target) || !this.isWholeModule(fa.target.simpleName)) return fa;
+                const local = fa.target.simpleName;
+                const name = fa.name.element.simpleName;
+                if (isOptionType(name) && inTypePosition(this.cursor)) return this.optionType(fa);
+                if (!HPAGENT_CLASSES.has(name)) return fa;
+                if (inTypePosition(this.cursor) || this.found.typeOnly.has(local)) return this.typeReference(fa, local);
+                if (this.surveying && isValueUse(this.cursor)) this.stranded.add(local);
+                return fa;
+            }
+
             /**
-             * A union of types, where an hpagent class becomes `HttpsProxyAgent<string>`. Both classes
-             * collapse onto the same type, so a union naming both keeps one of them.
+             * The builtin agent for a type naming an hpagent class, which is all hpagent declared it as. `typeof`
+             * names the constructor instead, and so becomes `https-proxy-agent`'s class.
+             */
+            private typeReference(type: J.Identifier | J.FieldAccess, local: string): J {
+                const typeQuery = this.cursor.parentTree()?.value?.kind === JS.Kind.TypeQuery;
+                if (this.surveying) {
+                    if (typeQuery) this.referenced.add(local);
+                    return type;
+                }
+                if (this.stranded.has(local)) return type;
+                const memberAccess = type.kind === J.Kind.FieldAccess ? type : undefined;
+                if (typeQuery) return this.migratedCallee(type, {local, memberAccess});
+                const member = memberAccess ? memberAccess.name.element.simpleName : this.bindings.get(local)!;
+                const module = builtinAgentModule(member);
+                const agent = builtinAgentType(this.builtinLocals.get(module), builtinSpecifier(compilationUnitOf(this)!, module), type.prefix);
+                this.producedTypes.add(agent.id);
+                return agent;
+            }
+
+            /**
+             * A union of types, whose hpagent arms have already become builtin agents, which may now repeat an arm
+             * the union already had, as `http.Agent | HttpProxyAgent` does. A repeat this produced is dropped.
              */
             protected override async visitUnion(union: JS.Union, p: ExecutionContext): Promise<J | undefined> {
                 const u = await super.visitUnion(union, p) as JS.Union;
-                if (u?.kind !== JS.Kind.Union) return u;
-                let changed = false;
+                if (u?.kind !== JS.Kind.Union || this.surveying) return u;
                 const seen = new Set<string>();
                 const types: J.RightPadded<any>[] = [];
                 for (const padded of u.types) {
-                    const replacement = this.migratedTypeReference(padded.element);
-                    if (replacement) changed = true;
-                    const element = replacement ?? padded.element;
-                    const key = typeKey(element);
+                    const key = typeKey(padded.element);
                     // A duplicate arm says nothing the first one didn't.
-                    if (key !== undefined && seen.has(key)) {
-                        changed = true;
-                        continue;
-                    }
+                    if (key !== undefined && this.producedTypes.has(padded.element.id) && seen.has(key)) continue;
                     if (key !== undefined) seen.add(key);
-                    types.push(replacement ? {...padded, element: replacement} : padded);
+                    types.push(padded);
                 }
-                if (!changed) return u;
+                if (types.length === u.types.length) return u;
                 // The space before `|` lives on each arm's right padding, so dropping the last arm
                 // has to hand its padding to whichever arm is last now.
                 types[types.length - 1] = {...types[types.length - 1], after: u.types[u.types.length - 1].after};
                 return {...u, types} as JS.Union;
             }
 
-            /** A type annotation naming an hpagent class on its own, outside any union. */
-            protected override async visitTypeInfo(typeInfo: JS.TypeInfo, p: ExecutionContext): Promise<J | undefined> {
-                const t = await super.visitTypeInfo(typeInfo, p) as JS.TypeInfo;
-                if (t?.kind !== JS.Kind.TypeInfo) return t;
-                const replacement = this.migratedTypeReference(t.typeIdentifier as J);
-                return replacement ? {...t, typeIdentifier: replacement} as JS.TypeInfo : t;
+            /** `ConstructorParameters<typeof HttpProxyAgent>[0]`, hpagent's options object, which the adapter now takes. */
+            protected override async visitIndexedAccessType(indexedAccessType: JS.IndexedAccessType, p: ExecutionContext): Promise<J | undefined> {
+                const operand = constructorOptionsOf(indexedAccessType);
+                const site = operand && this.hpagentSite(operand);
+                if (!site || this.surveying || this.stranded.has(site.local)) return super.visitIndexedAccessType(indexedAccessType, p);
+                this.typeNeeded = true;
+                return {
+                    kind: J.Kind.Identifier, id: randomId(), prefix: indexedAccessType.prefix, markers: emptyMarkers,
+                    annotations: [], simpleName: this.typeName
+                } as J.Identifier;
             }
 
-            /** `HttpsProxyAgent<string>` for a type reference to an hpagent class, or undefined for anything else. */
-            private migratedTypeReference(type: J): J.ParameterizedType | undefined {
-                if (!isIdentifier(type)) return undefined;
-                const member = this.bindings.get(type.simpleName);
-                if (member === undefined || !HPAGENT_CLASSES.has(member) || !isModuleScoped(this.cursor, type.simpleName)) {
-                    return undefined;
+            /** `({HttpsProxyAgent} = require('hpagent'))` into a `let`, once every name it assigns has moved. */
+            override async visitAssignment(assignment: J.Assignment, p: ExecutionContext): Promise<J | undefined> {
+                const a = await super.visitAssignment(assignment, p) as J.Assignment;
+                if (this.surveying || a?.kind !== J.Kind.Assignment || !isHpagentRequire(a.assignment.element) ||
+                    !isObjectLiteral(a.variable)) {
+                    return a;
                 }
-                if (this.surveying) {
-                    this.typeUses.add(type.simpleName);
-                    return undefined;
+                const pattern = a.variable;
+                const members = objectMembers(pattern) as JS.PropertyAssignment[];
+                const locals = members.map(m => (m.initializer ?? m.name.element) as J.Identifier);
+                if (!locals.every(l => this.found.assigned.has(l.simpleName) && !this.stranded.has(l.simpleName))) return a;
+                const statements = pattern.body!.statements.map(padded => {
+                    const prop = padded.element as JS.PropertyAssignment;
+                    if (prop.kind !== JS.Kind.PropertyAssignment || propertyName(prop) === TARGET_CLASS) return padded;
+                    const name = prop.name.element as J.Identifier;
+                    // `{HttpProxyAgent}` keeps its local, so it reads the new class off as `{HttpsProxyAgent: HttpProxyAgent}`.
+                    const element = prop.initializer
+                        ? {...prop, name: {...prop.name, element: {...name, simpleName: TARGET_CLASS}}}
+                        : {
+                            ...prop,
+                            name: {...prop.name, element: {...name, id: randomId(), simpleName: TARGET_CLASS}},
+                            assigmentToken: JS.PropertyAssignment.Token.Colon,
+                            initializer: {...name, prefix: space(' ')}
+                        };
+                    return {...padded, element};
+                });
+                return {
+                    ...a,
+                    variable: {...pattern, body: {...pattern.body!, statements}},
+                    assignment: {...a.assignment, element: movedRequireCall(a.assignment.element)}
+                } as J.Assignment;
+            }
+
+            /**
+             * `jest.mock('hpagent')` and `vi.mock('hpagent', ...)` replace the module the code under test now imports
+             * instead, once this file's own hpagent bindings have all moved; `jest.spyOn(hpagent, 'HttpProxyAgent')`
+             * spies on the one class both became.
+             */
+            override async visitMethodInvocation(method: J.MethodInvocation, p: ExecutionContext): Promise<J | undefined> {
+                const m = await super.visitMethodInvocation(method, p) as J.MethodInvocation;
+                if (this.surveying || m?.kind !== J.Kind.MethodInvocation) return m;
+                const args = m.arguments.elements;
+                const first = args[0]?.element;
+                if (isMockCall(m) && first?.kind === J.Kind.Literal && HPAGENT_MODULES.has(stringLiteral(first) ?? '') &&
+                    [...this.bindings.keys()].every(local => !this.stranded.has(local))) {
+                    return {...m, arguments: {...m.arguments, elements: [{...args[0], element: retargeted(first as J.Literal)}, ...args.slice(1)]}} as J.MethodInvocation;
+                }
+                const spied = spiedClass(m);
+                if (spied && spied !== TARGET_CLASS && first && isIdentifier(first) && this.bindings.has(first.simpleName) &&
+                    this.bindings.get(first.simpleName) === undefined && !this.stranded.has(first.simpleName)) {
+                    const literal = args[1].element as J.Literal;
+                    const quote = (literal.valueSource ?? "'").charAt(0);
+                    const renamed = {...literal, value: TARGET_CLASS, valueSource: `${quote}${TARGET_CLASS}${quote}`};
+                    return {...m, arguments: {...m.arguments, elements: [args[0], {...args[1], element: renamed}, ...args.slice(2)]}} as J.MethodInvocation;
                 }
-                if (this.stranded.has(type.simpleName)) return undefined;
-                const local = this.targetLocals.get(type.simpleName) ?? type.simpleName;
-                return targetTypeReference(local, type.prefix);
+                return m;
+            }
+
+            /** A `require` of hpagent, at the top level or in a block, once every name it binds has moved. */
+            override async visitVariableDeclarations(varDecls: J.VariableDeclarations, p: ExecutionContext): Promise<J | undefined> {
+                const v = await super.visitVariableDeclarations(varDecls, p) as J.VariableDeclarations;
+                if (this.surveying || v?.kind !== J.Kind.VariableDeclarations) return v;
+                let changed = false;
+                const variables = v.variables.map(padded => {
+                    const variable = padded.element;
+                    const initializer = variable.initializer?.element;
+                    if (!isHpagentRequire(initializer)) return padded;
+                    const pattern = variable.name as J;
+                    const names = isIdentifier(pattern) ? [pattern.simpleName] : bindingNames(pattern).map(b => b.name);
+                    // One specifier serves every name the declaration binds, so it moves once they all have.
+                    if (names.length === 0 || names.some(n => !this.migrated.has(n) || this.stranded.has(n))) return padded;
+                    changed = true;
+                    return {
+                        ...padded,
+                        element: {
+                            ...variable,
+                            name: renameBindings(pattern, this.targetLocals, this.merged),
+                            initializer: {...variable.initializer!, element: movedRequireCall(initializer!)}
+                        }
+                    };
+                });
+                return changed ? {...v, variables} as J.VariableDeclarations : v;
             }
 
-            /** The local binding a `new` site constructs through, and the member name it names on it. */
+            /** The local binding a `new` or `instanceof` site names the class through, and the member it reads. */
             private hpagentSite(clazz: J): {local: string; memberAccess?: J.FieldAccess} | undefined {
-                if (isIdentifier(clazz)) {
-                    const member = this.bindings.get(clazz.simpleName);
-                    return member !== undefined && HPAGENT_CLASSES.has(member) && isModuleScoped(this.cursor, clazz.simpleName)
-                        ? {local: clazz.simpleName}
-                        : undefined;
-                }
+                if (isIdentifier(clazz)) return this.isClass(clazz.simpleName) ? {local: clazz.simpleName} : undefined;
                 if (clazz.kind !== J.Kind.FieldAccess) return undefined;
                 const access = clazz as J.FieldAccess;
                 const target = access.target;
                 if (!isIdentifier(target) || !HPAGENT_CLASSES.has(access.name.element.simpleName)) return undefined;
                 // Only a binding of the whole module has the classes as its members.
-                return this.bindings.has(target.simpleName) && this.bindings.get(target.simpleName) === undefined &&
-                    isModuleScoped(this.cursor, target.simpleName)
-                    ? {local: target.simpleName, memberAccess: access}
-                    : undefined;
+                return this.isWholeModule(target.simpleName) ? {local: target.simpleName, memberAccess: access} : undefined;
             }
 
             /** The migrated argument list, or undefined where the options can't be split into one. */
@@ -471,7 +861,7 @@ export class ReplaceHpagent extends Recipe {
                     }
                 }
                 if (!proxy) return undefined;
-                // A name given twice would change which value wins; leave that to a human.
+                // A name given twice would change which value wins; leave that to the adapter.
                 const names = members
                     .filter(m => m.element.kind === JS.Kind.PropertyAssignment)
                     .map(m => propertyName(m.element as JS.PropertyAssignment));
@@ -479,53 +869,6 @@ export class ReplaceHpagent extends Recipe {
                 return {proxy, members, literal};
             }
 
-            /**
-             * Moves the `require`s of bindings whose every site was rewritten: the specifier becomes the new
-             * module, and an unaliased `HttpProxyAgent` the new module's name for the class. A declaration is
-             * only touched once every name it binds has migrated, since one specifier serves them all.
-             */
-            private rewriteRequires(cu: JS.CompilationUnit): JS.CompilationUnit {
-                if (this.requireBound.size === 0) return cu;
-                let changed = false;
-                const statements = cu.statements.map(padded => {
-                    const names = requireBoundNames({...cu, statements: [padded]} as JS.CompilationUnit);
-                    if (names.size === 0 || [...names].some(n => !this.migrated.has(n) || this.stranded.has(n))) return padded;
-                    const moved = this.movedRequire(padded.element);
-                    if (moved === padded.element) return padded;
-                    changed = true;
-                    return {...padded, element: moved};
-                });
-                return changed ? {...cu, statements} : cu;
-            }
-
-            /** `const {HttpProxyAgent} = require('hpagent')` with both the specifier and the member moved. */
-            private movedRequire(statement: J): J {
-                const decls = statement as J.VariableDeclarations;
-                if (decls?.kind !== J.Kind.VariableDeclarations) return statement;
-                const variables = decls.variables.map(padded => {
-                    const variable = padded.element;
-                    const initializer = variable.initializer?.element;
-                    if (requiredModule(initializer) === undefined) return padded;
-                    const call = initializer as J.MethodInvocation;
-                    const specifier = call.arguments.elements[0];
-                    const literal = specifier.element as J.Literal;
-                    const quote = (literal.valueSource ?? "'").charAt(0);
-                    const moved: J.Literal = {...literal, value: TARGET_MODULE, valueSource: `${quote}${TARGET_MODULE}${quote}`};
-                    return {
-                        ...padded,
-                        element: {
-                            ...variable,
-                            name: renameBindings(variable.name as J, this.targetLocals),
-                            initializer: {
-                                ...variable.initializer!,
-                                element: {...call, arguments: {...call.arguments, elements: [{...specifier, element: moved}]}}
-                            }
-                        }
-                    };
-                });
-                return {...decls, variables} as J;
-            }
-
             /**
              * `new X({proxy: p, ...rest})` as `new X(p, {...rest})`: the proxy expression takes the space the
              * literal opened with, and the literal itself is reused for the second argument so its members keep
@@ -543,17 +886,28 @@ export class ReplaceHpagent extends Recipe {
                 return {...n, class: this.migratedCallee(n.class!, site), arguments: {...n.arguments, elements}} as J.NewClass;
             }
 
-            /** The options literal with `proxy` gone, its first surviving member opening the object as the old one did. */
+            /**
+             * The options literal with `proxy` gone, its first surviving member opening the object as the old one
+             * did and its last closing it as the old one did, trailing comma included.
+             */
             private withMembers(rewrite: Rewrite): J.NewClass {
                 const original = paddedMembers(rewrite.literal);
-                const members = [...rewrite.members];
+                const trailing = (padded: J.RightPadded<J>) => padded.markers.markers.some(m => m.kind === J.Markers.TrailingComma);
+                // A member flattened out of `proxyRequestOptions` may close that literal with a comma of its own.
+                const members = rewrite.members.map((m, i) => i < rewrite.members.length - 1 && trailing(m)
+                    ? {...m, markers: {...m.markers, markers: m.markers.markers.filter(k => k.kind !== J.Markers.TrailingComma)}}
+                    : m);
                 if (members[0] !== original[0]) {
                     members[0] = {...members[0], element: {...members[0].element, prefix: original[0].element.prefix}};
                 }
+                const last = original[original.length - 1];
+                if (rewrite.members[rewrite.members.length - 1] !== last) {
+                    members[members.length - 1] = {...members[members.length - 1], after: last.after, markers: last.markers};
+                }
                 return {...rewrite.literal, prefix: space(' '), body: {...rewrite.literal.body!, statements: members}} as J.NewClass;
             }
 
-            /** The constructed name after the move: the binding's new local name, or the new class on a namespace. */
+            /** The class's name after the move: the binding's new local name, or the new class on a namespace. */
             private migratedCallee(clazz: J, site: {local: string; memberAccess?: J.FieldAccess}): any {
                 if (site.memberAccess) {
                     const access = site.memberAccess;
@@ -562,6 +916,43 @@ export class ReplaceHpagent extends Recipe {
                 const local = this.targetLocals.get(site.local) ?? site.local;
                 return {...(clazz as J.Identifier), simpleName: local};
             }
+
+            /** How the adapter names `https-proxy-agent`'s class: through a binding one of its call sites moved. */
+            private agentClass(): string {
+                const local = [...this.adapterLocals].find(l => !this.stranded.has(l))!;
+                return this.bindings.get(local) === undefined
+                    ? `${local}.${TARGET_CLASS}`
+                    : this.targetLocals.get(local) ?? local;
+            }
+
+            /** Appends the adapter and its options type, after the statements that use them. */
+            private async withAdapter(cu: JS.CompilationUnit, p: ExecutionContext): Promise<JS.CompilationUnit> {
+                const typeScript = !isJavaScript(cu.sourcePath);
+                const style = detectCodeStyle(await TreePrinters.print(cu));
+                const sources: GeneratedDeclaration[] = [];
+                if (this.adapterNeeded) sources.push(adapterSource(this.adapterName, this.typeName, this.agentClass(), typeScript, style));
+                if (typeScript) {
+                    sources.push(...adapterTypeSource(this.typeNeeded ? this.typeName : undefined,
+                        this.requestTypeNeeded ? this.requestTypeName : undefined, module => builtinSpecifier(cu, module), style));
+                }
+                // Where the project formats with Prettier, its own configuration lays the declarations out.
+                const prettier = findMarker(cu, StyleKind.PrettierStyle) !== undefined;
+                let result = cu;
+                for (const {doc, code} of sources) {
+                    // Parsed rather than templated, so the code keeps the layout written for this file's style.
+                    const parsed = await new JavaScriptParser().parseOnly({
+                        text: `/*${doc}*/\n${code}\n`, sourcePath: typeScript ? 'adapter.ts' : 'adapter.js'
+                    }) as JS.CompilationUnit;
+                    if (parsed.kind !== JS.Kind.CompilationUnit || parsed.statements.length !== 1) continue;
+                    const statement = parsed.statements[0];
+                    const parent = new Cursor(result, this.cursor);
+                    // The parser files a leading comment under the compilation unit rather than the statement.
+                    let declaration = {...statement.element, prefix: {...parsed.prefix, whitespace: '\n\n'}} as J;
+                    if (prettier) declaration = await autoFormat(declaration, p, undefined, parent);
+                    result = {...result, statements: [...result.statements, {...statement, element: declaration}]} as JS.CompilationUnit;
+                }
+                return result;
+            }
         };
     }
 }