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

package/dist/migrate/hpagent/replace-hpagent.js

@@ -19,44 +19,24 @@ exports.ReplaceHpagent = void 0;
 const rewrite_1 = require("@openrewrite/rewrite");
 const java_1 = require("@openrewrite/rewrite/java");
 const javascript_1 = require("@openrewrite/rewrite/javascript");
+const code_style_1 = require("../code-style");
 const module_bindings_1 = require("../module-bindings");
 const hpagent_support_1 = require("./hpagent-support");
-function requireBoundNames(cu) {
-    var _a, _b;
-    const names = new Set();
-    for (const padded of cu.statements) {
-        for (const decl of (0, javascript_1.declarationsOf)(padded.element)) {
-            for (const v of decl.variables) {
-                const variable = v.element;
-                if (!hpagent_support_1.HPAGENT_MODULES.has((_b = (0, module_bindings_1.requiredModule)((_a = variable.initializer) === null || _a === void 0 ? void 0 : _a.element)) !== null && _b !== void 0 ? _b : ''))
-                    continue;
-                for (const name of boundNames(variable.name))
-                    names.add(name);
-            }
-        }
-    }
-    return names;
-}
-function boundNames(target) {
-    if ((0, java_1.isIdentifier)(target))
-        return [target.simpleName];
-    if (target.kind !== javascript_1.JS.Kind.ObjectBindingPattern)
-        return [];
-    return target.bindings.elements.flatMap(padded => {
-        const binding = padded.element;
-        if ((0, java_1.isIdentifier)(binding))
-            return [binding.simpleName];
-        if (binding.kind !== javascript_1.JS.Kind.BindingElement)
-            return [];
-        const name = binding.name;
-        return (0, java_1.isIdentifier)(name) ? [name.simpleName] : [];
-    });
+function boundLocal(binding) {
+    if ((0, java_1.isIdentifier)(binding))
+        return binding.simpleName;
+    if (binding.kind !== javascript_1.JS.Kind.BindingElement)
+        return undefined;
+    const name = binding.name;
+    return (0, java_1.isIdentifier)(name) ? name.simpleName : undefined;
 }
-function renameBindings(target, targetLocals) {
+function renameBindings(target, targetLocals, merged) {
     if (target.kind !== javascript_1.JS.Kind.ObjectBindingPattern)
         return target;
     const pattern = target;
-    const elements = pattern.bindings.elements.map(padded => {
+    const original = pattern.bindings.elements;
+    const kept = original.filter(padded => { var _a; return !merged.has((_a = boundLocal(padded.element)) !== null && _a !== void 0 ? _a : ''); });
+    const elements = kept.map(padded => {
         var _a;
         const binding = padded.element;
         if ((0, java_1.isIdentifier)(binding)) {
@@ -76,18 +56,71 @@ function renameBindings(target, targetLocals) {
         if (!(0, java_1.isIdentifier)(name))
             return padded;
         const renamed = targetLocals.get(name.simpleName);
-        return renamed && renamed !== name.simpleName
-            ? Object.assign(Object.assign({}, padded), { element: Object.assign(Object.assign({}, element), { name: Object.assign(Object.assign({}, name), { simpleName: renamed }) }) }) : padded;
+        if (!renamed || renamed === name.simpleName)
+            return padded;
+        if (renamed === hpagent_support_1.TARGET_CLASS)
+            return Object.assign(Object.assign({}, padded), { element: Object.assign(Object.assign({}, element), { name: Object.assign(Object.assign({}, name), { simpleName: renamed }) }) });
+        return Object.assign(Object.assign({}, padded), { element: Object.assign(Object.assign({}, element), { propertyName: (0, java_1.rightPadded)(Object.assign(Object.assign({}, name), { id: (0, rewrite_1.randomId)(), simpleName: hpagent_support_1.TARGET_CLASS }), java_1.emptySpace), name: Object.assign(Object.assign({}, name), { prefix: (0, java_1.space)(' '), simpleName: renamed }) }) });
     });
+    if (elements.length > 0 && kept[kept.length - 1] !== original[original.length - 1]) {
+        elements[elements.length - 1] = Object.assign(Object.assign({}, elements[elements.length - 1]), { after: original[original.length - 1].after });
+    }
     return Object.assign(Object.assign({}, pattern), { bindings: Object.assign(Object.assign({}, pattern.bindings), { elements }) });
 }
+function retargeted(literal) {
+    var _a;
+    const quote = ((_a = literal.valueSource) !== null && _a !== void 0 ? _a : "'").charAt(0);
+    return Object.assign(Object.assign({}, literal), { value: hpagent_support_1.TARGET_MODULE, valueSource: `${quote}${hpagent_support_1.TARGET_MODULE}${quote}` });
+}
+function movedRequireCall(e) {
+    if (e.kind === javascript_1.JS.Kind.As) {
+        const as = e;
+        return Object.assign(Object.assign({}, as), { left: Object.assign(Object.assign({}, as.left), { element: movedRequireCall(as.left.element) }), right: movedImportType(as.right) });
+    }
+    const call = e;
+    const specifier = call.arguments.elements[0];
+    return Object.assign(Object.assign({}, call), { arguments: Object.assign(Object.assign({}, call.arguments), { elements: [Object.assign(Object.assign({}, specifier), { element: retargeted(specifier.element) })] }) });
+}
+function movedImportType(type) {
+    if (type.kind !== javascript_1.JS.Kind.ImportType)
+        return type;
+    const importType = type;
+    const elements = importType.argumentAndAttributes.elements.map(padded => {
+        var _a;
+        const argument = padded.element;
+        if (argument.kind !== javascript_1.JS.Kind.LiteralType)
+            return padded;
+        const literal = argument.literal;
+        return hpagent_support_1.HPAGENT_MODULES.has((_a = (0, hpagent_support_1.stringLiteral)(literal)) !== null && _a !== void 0 ? _a : '')
+            ? Object.assign(Object.assign({}, padded), { element: Object.assign(Object.assign({}, argument), { literal: retargeted(literal) }) }) : padded;
+    });
+    return Object.assign(Object.assign({}, importType), { argumentAndAttributes: Object.assign(Object.assign({}, importType.argumentAndAttributes), { elements }) });
+}
 function typeKey(type) {
+    var _a, _b;
     if ((0, java_1.isIdentifier)(type))
         return type.simpleName;
+    if (type.kind === java_1.J.Kind.FieldAccess) {
+        const access = type;
+        return (0, java_1.isIdentifier)(access.target) ? `${access.target.simpleName}.${access.name.element.simpleName}` : undefined;
+    }
+    if (type.kind === javascript_1.JS.Kind.ImportType) {
+        const importType = type;
+        const module = (_a = importType.argumentAndAttributes.elements[0]) === null || _a === void 0 ? void 0 : _a.element;
+        const name = (_b = importType.qualifier) === null || _b === void 0 ? void 0 : _b.element;
+        return (module === null || module === void 0 ? void 0 : module.kind) === javascript_1.JS.Kind.LiteralType && name && (0, java_1.isIdentifier)(name)
+            ? `import(${(0, hpagent_support_1.stringLiteral)(module.literal)}).${name.simpleName}`
+            : undefined;
+    }
     if (type.kind !== java_1.J.Kind.ParameterizedType)
         return undefined;
     const clazz = type.class;
-    return (0, java_1.isIdentifier)(clazz) ? `${clazz.simpleName}<>` : undefined;
+    if ((0, java_1.isIdentifier)(clazz))
+        return `${clazz.simpleName}<>`;
+    if (clazz.kind !== java_1.J.Kind.FieldAccess)
+        return undefined;
+    const access = clazz;
+    return (0, java_1.isIdentifier)(access.target) ? `${access.target.simpleName}.${access.name.element.simpleName}<>` : undefined;
 }
 function alwaysDefined(proxy) {
     switch (proxy.kind) {
@@ -151,6 +184,54 @@ function paddedMembers(literal) {
     var _a, _b;
     return ((_b = (_a = literal.body) === null || _a === void 0 ? void 0 : _a.statements) !== null && _b !== void 0 ? _b : []).filter(padded => padded.element.kind !== java_1.J.Kind.Empty);
 }
+function builtinSpecifier(cu, module) {
+    const prefixed = cu.statements.some(padded => {
+        const statement = padded.element;
+        const specifier = (statement === null || statement === void 0 ? void 0 : statement.kind) === javascript_1.JS.Kind.Import
+            ? (0, module_bindings_1.importModule)(statement)
+            : (0, javascript_1.declarationsOf)(statement).map(d => d.variables.map(v => { var _a; return (0, module_bindings_1.requiredModule)((_a = v.element.initializer) === null || _a === void 0 ? void 0 : _a.element); }).find(Boolean)).find(Boolean);
+        return specifier === null || specifier === void 0 ? void 0 : specifier.startsWith('node:');
+    });
+    return prefixed ? `node:${module}` : module;
+}
+function isOptionType(member) {
+    return hpagent_support_1.ADAPTED_TYPES.has(member) || member === 'ProxyAgentRequestOptions';
+}
+function isAmbientHpagent(statement) {
+    var _a;
+    if ((statement === null || statement === void 0 ? void 0 : statement.kind) !== javascript_1.JS.Kind.NamespaceDeclaration)
+        return false;
+    const declaration = statement;
+    return declaration.keywordType.element === "Module" &&
+        hpagent_support_1.HPAGENT_MODULES.has((_a = (0, hpagent_support_1.stringLiteral)(declaration.name.element)) !== null && _a !== void 0 ? _a : '');
+}
+function constructorOptionsOf(type) {
+    var _a;
+    const index = type.indexType.element.element;
+    if (index.kind !== javascript_1.JS.Kind.LiteralType || index.literal.kind !== java_1.J.Kind.Literal ||
+        index.literal.value !== 0) {
+        return undefined;
+    }
+    if (type.objectType.kind !== java_1.J.Kind.ParameterizedType)
+        return undefined;
+    const parameterized = type.objectType;
+    const query = (_a = parameterized.typeParameters) === null || _a === void 0 ? void 0 : _a.elements;
+    if (!(0, java_1.isIdentifier)(parameterized.class) || parameterized.class.simpleName !== 'ConstructorParameters' ||
+        (query === null || query === void 0 ? void 0 : query.length) !== 1 || query[0].element.kind !== javascript_1.JS.Kind.TypeQuery) {
+        return undefined;
+    }
+    return query[0].element.typeExpression;
+}
+function literalProxy(options) {
+    if (!(0, hpagent_support_1.isObjectLiteral)(options))
+        return undefined;
+    for (const padded of paddedMembers(options)) {
+        const option = (0, hpagent_support_1.classifyOption)(padded.element);
+        if (option.kind === 'proxy')
+            return option.value;
+    }
+    return undefined;
+}
 class ReplaceHpagent extends rewrite_1.Recipe {
     constructor(options) {
         super(options);
@@ -163,11 +244,19 @@ class ReplaceHpagent extends rewrite_1.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.";
         this.tags = ["hpagent", "https-proxy-agent"];
     }
     editor() {
@@ -177,62 +266,94 @@ class ReplaceHpagent extends rewrite_1.Recipe {
             return new class extends javascript_1.JavaScriptVisitor {
                 constructor() {
                     super(...arguments);
+                    this.found = (0, hpagent_support_1.emptyHpagentBindings)();
                     this.bindings = new Map();
                     this.migrated = new Set();
                     this.stranded = new Set();
                     this.targetLocals = new Map();
-                    this.requireBound = new Set();
                     this.surveying = false;
                     this.merged = new Set();
                     this.folds = [];
-                    this.typeUses = new Set();
+                    this.adapterLocals = new Set();
+                    this.referenced = new Set();
+                    this.builtinLocals = new Map();
+                    this.producedTypes = new Set();
+                    this.adapterName = hpagent_support_1.ADAPTER_FUNCTION;
+                    this.typeName = hpagent_support_1.ADAPTER_TYPE;
+                    this.requestTypeName = hpagent_support_1.REQUEST_TYPE;
+                    this.adapterNeeded = false;
+                    this.typeNeeded = false;
+                    this.requestTypeNeeded = false;
+                    this.movedInPlace = new Set();
                 }
                 visitJsCompilationUnit(cu, p) {
                     const _super = Object.create(null, {
                         visitJsCompilationUnit: { get: () => super.visitJsCompilationUnit }
                     });
                     return __awaiter(this, void 0, void 0, function* () {
-                        this.bindings = (0, hpagent_support_1.bindingsOf)(cu, hpagent_support_1.HPAGENT_MODULES);
+                        if (!this.surveying && cu.statements.some(padded => isAmbientHpagent(padded.element))) {
+                            cu = Object.assign(Object.assign({}, cu), { statements: cu.statements.filter(padded => !isAmbientHpagent(padded.element)) });
+                        }
+                        this.found = (0, hpagent_support_1.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 = [...(0, module_bindings_1.bindingsOf)(cu, new Set([module, `node:${module}`]))].find(([, member]) => member === undefined);
+                            if (whole)
+                                this.builtinLocals.set(module, whole[0]);
+                        }
+                        const used = (0, javascript_1.namesUsedIn)(cu);
+                        this.adapterName = (0, javascript_1.deconflict)(hpagent_support_1.ADAPTER_FUNCTION, name => used.has(name));
+                        this.typeName = (0, javascript_1.deconflict)(hpagent_support_1.ADAPTER_TYPE, name => used.has(name));
+                        this.requestTypeName = (0, javascript_1.deconflict)(hpagent_support_1.REQUEST_TYPE, name => used.has(name));
                         this.surveying = true;
                         yield _super.visitJsCompilationUnit.call(this, cu, p);
                         this.surveying = false;
-                        for (const local of this.typeUses)
+                        for (const local of this.targetLocals.keys())
                             this.migrated.add(local);
                         for (const fold of this.folds) {
-                            if (fold.some(local => this.stranded.has(local) || !this.migrated.has(local))) {
+                            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)))
+                        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 = yield _super.visitJsCompilationUnit.call(this, cu, p);
+                        let result = yield _super.visitJsCompilationUnit.call(this, cu, p);
+                        if (this.adapterNeeded || this.typeNeeded || this.requestTypeNeeded)
+                            result = yield this.withAdapter(result, p);
                         this.rebindMigrated();
-                        return this.rewriteRequires(result);
+                        return result;
                     });
                 }
                 planNames(cu) {
                     var _a, _b;
-                    const declared = (0, javascript_1.namesDeclaredIn)(cu);
-                    const classes = [...this.bindings].filter(([, member]) => member !== undefined && hpagent_support_1.HPAGENT_CLASSES.has(member));
-                    const foldable = new Set(classes.filter(([local, member]) => local === member).map(([local]) => local));
+                    const used = (0, javascript_1.namesUsedIn)(cu);
+                    const movable = [...this.bindings].filter(([, member]) => member === undefined || hpagent_support_1.HPAGENT_CLASSES.has(member));
+                    const foldable = new Set(movable.filter(([local, member]) => local === member).map(([local]) => local));
+                    const targetClass = (0, javascript_1.deconflict)(hpagent_support_1.TARGET_CLASS, name => used.has(name) && !foldable.has(name));
                     const targets = new Map();
-                    for (const [local, member] of this.bindings) {
-                        const target = member !== undefined && local === member ? hpagent_support_1.TARGET_CLASS : local;
-                        if (target !== local && declared.has(target) && !foldable.has(target)) {
-                            this.stranded.add(local);
-                            continue;
-                        }
+                    for (const [local, member] of movable) {
+                        const target = member !== undefined && local === member && !this.found.assigned.has(local) ? targetClass : local;
                         this.targetLocals.set(local, target);
                         targets.set(target, [...((_a = targets.get(target)) !== null && _a !== void 0 ? _a : []), local]);
                     }
@@ -253,23 +374,72 @@ class ReplaceHpagent extends rewrite_1.Recipe {
                 }
                 rebindMigrated() {
                     for (const local of this.migrated) {
-                        if (this.stranded.has(local) || this.requireBound.has(local))
+                        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)) {
                             (0, javascript_1.maybeUnbind)(this, { module: 'hpagent', member });
                             continue;
                         }
+                        if (!this.referenced.has(local)) {
+                            (0, javascript_1.maybeUnbind)(this, member === undefined ? { module: 'hpagent' } : { module: 'hpagent', member });
+                            continue;
+                        }
                         if (member === undefined) {
                             (0, javascript_1.maybeRebind)(this, { from: { module: 'hpagent' }, to: { module: hpagent_support_1.TARGET_MODULE } });
                         }
                         else {
+                            const target = this.targetLocals.get(local);
                             (0, javascript_1.maybeRebind)(this, {
                                 from: { module: 'hpagent', member },
-                                to: Object.assign({ module: hpagent_support_1.TARGET_MODULE, member: hpagent_support_1.TARGET_CLASS }, (local === member ? {} : { alias: local }))
+                                to: Object.assign({ module: hpagent_support_1.TARGET_MODULE, member: hpagent_support_1.TARGET_CLASS }, (target === hpagent_support_1.TARGET_CLASS ? {} : { alias: target }))
                             });
                         }
                     }
+                    for (const [local, member] of this.bindings) {
+                        if (member !== undefined && isOptionType(member) && !this.found.requireBound.has(local)) {
+                            (0, javascript_1.maybeUnbind)(this, { module: 'hpagent', member });
+                        }
+                    }
+                }
+                visitImportDeclaration(jsImport, p) {
+                    const _super = Object.create(null, {
+                        visitImportDeclaration: { get: () => super.visitImportDeclaration }
+                    });
+                    return __awaiter(this, void 0, void 0, function* () {
+                        var _a, _b;
+                        const imp = yield _super.visitImportDeclaration.call(this, jsImport, p);
+                        const clause = imp === null || imp === void 0 ? void 0 : imp.importClause;
+                        if (this.surveying || (imp === null || imp === void 0 ? void 0 : imp.kind) !== javascript_1.JS.Kind.Import || !clause || clause.typeOnly ||
+                            !hpagent_support_1.HPAGENT_MODULES.has((_a = (0, module_bindings_1.importModule)(imp)) !== null && _a !== void 0 ? _a : '')) {
+                            return imp;
+                        }
+                        const named = clause.namedBindings;
+                        const namespace = (named === null || named === void 0 ? void 0 : named.kind) === javascript_1.JS.Kind.Alias ? named : undefined;
+                        const defaultName = !named ? (_b = clause.name) === null || _b === void 0 ? void 0 : _b.element : undefined;
+                        const local = defaultName !== null && defaultName !== void 0 ? defaultName : (!clause.name && namespace && (0, java_1.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 = Object.assign(Object.assign({}, imp), { moduleSpecifier: Object.assign(Object.assign({}, imp.moduleSpecifier), { element: retargeted(imp.moduleSpecifier.element) }) });
+                        if (!defaultName)
+                            return moved;
+                        const star = { kind: java_1.J.Kind.Identifier, id: (0, rewrite_1.randomId)(), prefix: java_1.emptySpace, markers: rewrite_1.emptyMarkers, annotations: [], simpleName: '*' };
+                        const alias = {
+                            kind: javascript_1.JS.Kind.Alias, id: (0, rewrite_1.randomId)(), prefix: defaultName.prefix, markers: rewrite_1.emptyMarkers,
+                            propertyName: (0, java_1.rightPadded)(star, (0, java_1.space)(' ')), alias: Object.assign(Object.assign({}, defaultName), { prefix: (0, java_1.space)(' ') })
+                        };
+                        return Object.assign(Object.assign({}, moved), { importClause: Object.assign(Object.assign({}, clause), { name: undefined, namedBindings: alias }), moduleSpecifier: Object.assign(Object.assign({}, moved.moduleSpecifier), { before: clause.name.after }) });
+                    });
+                }
+                isWholeModule(name) {
+                    return this.bindings.has(name) && this.bindings.get(name) === undefined && (0, hpagent_support_1.resolvesToBinding)(this.cursor, name, this.found);
+                }
+                isClass(name) {
+                    const member = this.bindings.get(name);
+                    return member !== undefined && hpagent_support_1.HPAGENT_CLASSES.has(member) && (0, hpagent_support_1.resolvesToBinding)(this.cursor, name, this.found);
                 }
                 visitNewClass(newClass, p) {
                     const _super = Object.create(null, {
@@ -283,95 +453,276 @@ class ReplaceHpagent extends rewrite_1.Recipe {
                         if (!site)
                             return n;
                         const rewrite = this.rewriteOf(n);
+                        const adaptable = !rewrite && (0, hpagent_support_1.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))
+                        if (this.stranded.has(site.local) || !(rewrite || adaptable))
                             return n;
-                        const migrated = this.applyRewrite(n, site, rewrite);
-                        return isJavaScript((0, javascript_1.compilationUnitOf)(this).sourcePath) && !alwaysDefined(rewrite.proxy) && readsOnly(rewrite.proxy)
-                            ? whenDefined(rewrite.proxy, migrated)
+                        const migrated = rewrite ? this.applyRewrite(n, site, rewrite) : this.adapterCall(n);
+                        const proxy = rewrite ? rewrite.proxy : literalProxy((0, hpagent_support_1.constructionArgument)(n));
+                        return proxy && isJavaScript((0, javascript_1.compilationUnitOf)(this).sourcePath) && !alwaysDefined(proxy) && readsOnly(proxy)
+                            ? whenDefined(proxy, migrated)
                             : migrated;
                     });
                 }
+                adapterCall(n) {
+                    this.adapterNeeded = true;
+                    this.typeNeeded = true;
+                    return {
+                        kind: java_1.J.Kind.MethodInvocation,
+                        id: (0, rewrite_1.randomId)(),
+                        prefix: n.prefix,
+                        markers: rewrite_1.emptyMarkers,
+                        name: {
+                            kind: java_1.J.Kind.Identifier, id: (0, rewrite_1.randomId)(), prefix: java_1.emptySpace, markers: rewrite_1.emptyMarkers,
+                            annotations: [], simpleName: this.adapterName
+                        },
+                        arguments: n.arguments,
+                    };
+                }
+                visitInstanceOf(instanceOf, p) {
+                    const _super = Object.create(null, {
+                        visitInstanceOf: { get: () => super.visitInstanceOf }
+                    });
+                    return __awaiter(this, void 0, void 0, function* () {
+                        const i = yield _super.visitInstanceOf.call(this, instanceOf, p);
+                        if ((i === null || i === void 0 ? void 0 : i.kind) !== java_1.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 : Object.assign(Object.assign({}, i), { class: this.migratedCallee(i.class, site) });
+                    });
+                }
+                visitIdentifier(identifier, p) {
+                    const _super = Object.create(null, {
+                        visitIdentifier: { get: () => super.visitIdentifier }
+                    });
+                    return __awaiter(this, void 0, void 0, function* () {
+                        const id = yield _super.visitIdentifier.call(this, identifier, p);
+                        if ((id === null || id === void 0 ? void 0 : id.kind) !== java_1.J.Kind.Identifier || !this.bindings.has(id.simpleName))
+                            return id;
+                        if (this.found.assignmentTargets.has(identifier.id))
+                            return id;
+                        if (!(0, javascript_1.isReference)(this.cursor, identifier) || !(0, hpagent_support_1.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_support_1.HPAGENT_CLASSES.has(member))
+                            return id;
+                        if (member !== undefined && ((0, hpagent_support_1.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;
+                        }
+                        if (this.surveying && (0, hpagent_support_1.isValueUse)(this.cursor))
+                            this.stranded.add(id.simpleName);
+                        return id;
+                    });
+                }
+                optionType(type) {
+                    if (this.surveying)
+                        return type;
+                    const request = type.kind === java_1.J.Kind.FieldAccess
+                        ? type.name.element.simpleName === 'ProxyAgentRequestOptions'
+                        : this.bindings.get(type.simpleName) === 'ProxyAgentRequestOptions';
+                    if (request)
+                        this.requestTypeNeeded = true;
+                    else
+                        this.typeNeeded = true;
+                    return {
+                        kind: java_1.J.Kind.Identifier, id: (0, rewrite_1.randomId)(), prefix: type.prefix, markers: rewrite_1.emptyMarkers,
+                        annotations: [], simpleName: request ? this.requestTypeName : this.typeName
+                    };
+                }
+                isSpiedModule(id) {
+                    var _a, _b;
+                    const parent = (_a = this.cursor.parentTree()) === null || _a === void 0 ? void 0 : _a.value;
+                    return (parent === null || parent === void 0 ? void 0 : parent.kind) === java_1.J.Kind.MethodInvocation && (0, hpagent_support_1.spiedClass)(parent) !== undefined &&
+                        ((_b = parent.arguments.elements[0]) === null || _b === void 0 ? void 0 : _b.element) === this.cursor.value;
+                }
+                visitFieldAccess(fieldAccess, p) {
+                    const _super = Object.create(null, {
+                        visitFieldAccess: { get: () => super.visitFieldAccess }
+                    });
+                    return __awaiter(this, void 0, void 0, function* () {
+                        const fa = yield _super.visitFieldAccess.call(this, fieldAccess, p);
+                        if ((fa === null || fa === void 0 ? void 0 : fa.kind) !== java_1.J.Kind.FieldAccess || !(0, java_1.isIdentifier)(fa.target) || !this.isWholeModule(fa.target.simpleName))
+                            return fa;
+                        const local = fa.target.simpleName;
+                        const name = fa.name.element.simpleName;
+                        if (isOptionType(name) && (0, hpagent_support_1.inTypePosition)(this.cursor))
+                            return this.optionType(fa);
+                        if (!hpagent_support_1.HPAGENT_CLASSES.has(name))
+                            return fa;
+                        if ((0, hpagent_support_1.inTypePosition)(this.cursor) || this.found.typeOnly.has(local))
+                            return this.typeReference(fa, local);
+                        if (this.surveying && (0, hpagent_support_1.isValueUse)(this.cursor))
+                            this.stranded.add(local);
+                        return fa;
+                    });
+                }
+                typeReference(type, local) {
+                    var _a, _b;
+                    const typeQuery = ((_b = (_a = this.cursor.parentTree()) === null || _a === void 0 ? void 0 : _a.value) === null || _b === void 0 ? void 0 : _b.kind) === javascript_1.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 === java_1.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 = (0, hpagent_support_1.builtinAgentModule)(member);
+                    const agent = (0, hpagent_support_1.builtinAgentType)(this.builtinLocals.get(module), builtinSpecifier((0, javascript_1.compilationUnitOf)(this), module), type.prefix);
+                    this.producedTypes.add(agent.id);
+                    return agent;
+                }
                 visitUnion(union, p) {
                     const _super = Object.create(null, {
                         visitUnion: { get: () => super.visitUnion }
                     });
                     return __awaiter(this, void 0, void 0, function* () {
                         const u = yield _super.visitUnion.call(this, union, p);
-                        if ((u === null || u === void 0 ? void 0 : u.kind) !== javascript_1.JS.Kind.Union)
+                        if ((u === null || u === void 0 ? void 0 : u.kind) !== javascript_1.JS.Kind.Union || this.surveying)
                             return u;
-                        let changed = false;
                         const seen = new Set();
                         const types = [];
                         for (const padded of u.types) {
-                            const replacement = this.migratedTypeReference(padded.element);
-                            if (replacement)
-                                changed = true;
-                            const element = replacement !== null && replacement !== void 0 ? replacement : padded.element;
-                            const key = typeKey(element);
-                            if (key !== undefined && seen.has(key)) {
-                                changed = true;
+                            const key = typeKey(padded.element);
+                            if (key !== undefined && this.producedTypes.has(padded.element.id) && seen.has(key))
                                 continue;
-                            }
                             if (key !== undefined)
                                 seen.add(key);
-                            types.push(replacement ? Object.assign(Object.assign({}, padded), { element: replacement }) : padded);
+                            types.push(padded);
                         }
-                        if (!changed)
+                        if (types.length === u.types.length)
                             return u;
                         types[types.length - 1] = Object.assign(Object.assign({}, types[types.length - 1]), { after: u.types[u.types.length - 1].after });
                         return Object.assign(Object.assign({}, u), { types });
                     });
                 }
-                visitTypeInfo(typeInfo, p) {
+                visitIndexedAccessType(indexedAccessType, p) {
                     const _super = Object.create(null, {
-                        visitTypeInfo: { get: () => super.visitTypeInfo }
+                        visitIndexedAccessType: { get: () => super.visitIndexedAccessType }
                     });
                     return __awaiter(this, void 0, void 0, function* () {
-                        const t = yield _super.visitTypeInfo.call(this, typeInfo, p);
-                        if ((t === null || t === void 0 ? void 0 : t.kind) !== javascript_1.JS.Kind.TypeInfo)
-                            return t;
-                        const replacement = this.migratedTypeReference(t.typeIdentifier);
-                        return replacement ? Object.assign(Object.assign({}, t), { typeIdentifier: replacement }) : t;
+                        const operand = constructorOptionsOf(indexedAccessType);
+                        const site = operand && this.hpagentSite(operand);
+                        if (!site || this.surveying || this.stranded.has(site.local))
+                            return _super.visitIndexedAccessType.call(this, indexedAccessType, p);
+                        this.typeNeeded = true;
+                        return {
+                            kind: java_1.J.Kind.Identifier, id: (0, rewrite_1.randomId)(), prefix: indexedAccessType.prefix, markers: rewrite_1.emptyMarkers,
+                            annotations: [], simpleName: this.typeName
+                        };
                     });
                 }
-                migratedTypeReference(type) {
-                    var _a;
-                    if (!(0, java_1.isIdentifier)(type))
-                        return undefined;
-                    const member = this.bindings.get(type.simpleName);
-                    if (member === undefined || !hpagent_support_1.HPAGENT_CLASSES.has(member) || !(0, hpagent_support_1.isModuleScoped)(this.cursor, type.simpleName)) {
-                        return undefined;
-                    }
-                    if (this.surveying) {
-                        this.typeUses.add(type.simpleName);
-                        return undefined;
-                    }
-                    if (this.stranded.has(type.simpleName))
-                        return undefined;
-                    const local = (_a = this.targetLocals.get(type.simpleName)) !== null && _a !== void 0 ? _a : type.simpleName;
-                    return (0, hpagent_support_1.targetTypeReference)(local, type.prefix);
+                visitAssignment(assignment, p) {
+                    const _super = Object.create(null, {
+                        visitAssignment: { get: () => super.visitAssignment }
+                    });
+                    return __awaiter(this, void 0, void 0, function* () {
+                        const a = yield _super.visitAssignment.call(this, assignment, p);
+                        if (this.surveying || (a === null || a === void 0 ? void 0 : a.kind) !== java_1.J.Kind.Assignment || !(0, hpagent_support_1.isHpagentRequire)(a.assignment.element) ||
+                            !(0, hpagent_support_1.isObjectLiteral)(a.variable)) {
+                            return a;
+                        }
+                        const pattern = a.variable;
+                        const members = (0, hpagent_support_1.objectMembers)(pattern);
+                        const locals = members.map(m => { var _a; return ((_a = m.initializer) !== null && _a !== void 0 ? _a : m.name.element); });
+                        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;
+                            if (prop.kind !== javascript_1.JS.Kind.PropertyAssignment || (0, hpagent_support_1.propertyName)(prop) === hpagent_support_1.TARGET_CLASS)
+                                return padded;
+                            const name = prop.name.element;
+                            const element = prop.initializer
+                                ? Object.assign(Object.assign({}, prop), { name: Object.assign(Object.assign({}, prop.name), { element: Object.assign(Object.assign({}, name), { simpleName: hpagent_support_1.TARGET_CLASS }) }) }) : Object.assign(Object.assign({}, prop), { name: Object.assign(Object.assign({}, prop.name), { element: Object.assign(Object.assign({}, name), { id: (0, rewrite_1.randomId)(), simpleName: hpagent_support_1.TARGET_CLASS }) }), assigmentToken: "Colon", initializer: Object.assign(Object.assign({}, name), { prefix: (0, java_1.space)(' ') }) });
+                            return Object.assign(Object.assign({}, padded), { element });
+                        });
+                        return Object.assign(Object.assign({}, a), { variable: Object.assign(Object.assign({}, pattern), { body: Object.assign(Object.assign({}, pattern.body), { statements }) }), assignment: Object.assign(Object.assign({}, a.assignment), { element: movedRequireCall(a.assignment.element) }) });
+                    });
+                }
+                visitMethodInvocation(method, p) {
+                    const _super = Object.create(null, {
+                        visitMethodInvocation: { get: () => super.visitMethodInvocation }
+                    });
+                    return __awaiter(this, void 0, void 0, function* () {
+                        var _a, _b, _c;
+                        const m = yield _super.visitMethodInvocation.call(this, method, p);
+                        if (this.surveying || (m === null || m === void 0 ? void 0 : m.kind) !== java_1.J.Kind.MethodInvocation)
+                            return m;
+                        const args = m.arguments.elements;
+                        const first = (_a = args[0]) === null || _a === void 0 ? void 0 : _a.element;
+                        if ((0, hpagent_support_1.isMockCall)(m) && (first === null || first === void 0 ? void 0 : first.kind) === java_1.J.Kind.Literal && hpagent_support_1.HPAGENT_MODULES.has((_b = (0, hpagent_support_1.stringLiteral)(first)) !== null && _b !== void 0 ? _b : '') &&
+                            [...this.bindings.keys()].every(local => !this.stranded.has(local))) {
+                            return Object.assign(Object.assign({}, m), { arguments: Object.assign(Object.assign({}, m.arguments), { elements: [Object.assign(Object.assign({}, args[0]), { element: retargeted(first) }), ...args.slice(1)] }) });
+                        }
+                        const spied = (0, hpagent_support_1.spiedClass)(m);
+                        if (spied && spied !== hpagent_support_1.TARGET_CLASS && first && (0, java_1.isIdentifier)(first) && this.bindings.has(first.simpleName) &&
+                            this.bindings.get(first.simpleName) === undefined && !this.stranded.has(first.simpleName)) {
+                            const literal = args[1].element;
+                            const quote = ((_c = literal.valueSource) !== null && _c !== void 0 ? _c : "'").charAt(0);
+                            const renamed = Object.assign(Object.assign({}, literal), { value: hpagent_support_1.TARGET_CLASS, valueSource: `${quote}${hpagent_support_1.TARGET_CLASS}${quote}` });
+                            return Object.assign(Object.assign({}, m), { arguments: Object.assign(Object.assign({}, m.arguments), { elements: [args[0], Object.assign(Object.assign({}, args[1]), { element: renamed }), ...args.slice(2)] }) });
+                        }
+                        return m;
+                    });
+                }
+                visitVariableDeclarations(varDecls, p) {
+                    const _super = Object.create(null, {
+                        visitVariableDeclarations: { get: () => super.visitVariableDeclarations }
+                    });
+                    return __awaiter(this, void 0, void 0, function* () {
+                        const v = yield _super.visitVariableDeclarations.call(this, varDecls, p);
+                        if (this.surveying || (v === null || v === void 0 ? void 0 : v.kind) !== java_1.J.Kind.VariableDeclarations)
+                            return v;
+                        let changed = false;
+                        const variables = v.variables.map(padded => {
+                            var _a;
+                            const variable = padded.element;
+                            const initializer = (_a = variable.initializer) === null || _a === void 0 ? void 0 : _a.element;
+                            if (!(0, hpagent_support_1.isHpagentRequire)(initializer))
+                                return padded;
+                            const pattern = variable.name;
+                            const names = (0, java_1.isIdentifier)(pattern) ? [pattern.simpleName] : (0, javascript_1.bindingNames)(pattern).map(b => b.name);
+                            if (names.length === 0 || names.some(n => !this.migrated.has(n) || this.stranded.has(n)))
+                                return padded;
+                            changed = true;
+                            return Object.assign(Object.assign({}, padded), { element: Object.assign(Object.assign({}, variable), { name: renameBindings(pattern, this.targetLocals, this.merged), initializer: Object.assign(Object.assign({}, variable.initializer), { element: movedRequireCall(initializer) }) }) });
+                        });
+                        return changed ? Object.assign(Object.assign({}, v), { variables }) : v;
+                    });
                 }
                 hpagentSite(clazz) {
-                    if ((0, java_1.isIdentifier)(clazz)) {
-                        const member = this.bindings.get(clazz.simpleName);
-                        return member !== undefined && hpagent_support_1.HPAGENT_CLASSES.has(member) && (0, hpagent_support_1.isModuleScoped)(this.cursor, clazz.simpleName)
-                            ? { local: clazz.simpleName }
-                            : undefined;
-                    }
+                    if ((0, java_1.isIdentifier)(clazz))
+                        return this.isClass(clazz.simpleName) ? { local: clazz.simpleName } : undefined;
                     if (clazz.kind !== java_1.J.Kind.FieldAccess)
                         return undefined;
                     const access = clazz;
                     const target = access.target;
                     if (!(0, java_1.isIdentifier)(target) || !hpagent_support_1.HPAGENT_CLASSES.has(access.name.element.simpleName))
                         return undefined;
-                    return this.bindings.has(target.simpleName) && this.bindings.get(target.simpleName) === undefined &&
-                        (0, hpagent_support_1.isModuleScoped)(this.cursor, target.simpleName)
-                        ? { local: target.simpleName, memberAccess: access }
-                        : undefined;
+                    return this.isWholeModule(target.simpleName) ? { local: target.simpleName, memberAccess: access } : undefined;
                 }
                 rewriteOf(n) {
                     const args = n.arguments.elements.map(a => a.element).filter(a => a.kind !== java_1.J.Kind.Empty);
@@ -418,41 +769,6 @@ class ReplaceHpagent extends rewrite_1.Recipe {
                         return undefined;
                     return { proxy, members, literal };
                 }
-                rewriteRequires(cu) {
-                    if (this.requireBound.size === 0)
-                        return cu;
-                    let changed = false;
-                    const statements = cu.statements.map(padded => {
-                        const names = requireBoundNames(Object.assign(Object.assign({}, cu), { statements: [padded] }));
-                        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 Object.assign(Object.assign({}, padded), { element: moved });
-                    });
-                    return changed ? Object.assign(Object.assign({}, cu), { statements }) : cu;
-                }
-                movedRequire(statement) {
-                    const decls = statement;
-                    if ((decls === null || decls === void 0 ? void 0 : decls.kind) !== java_1.J.Kind.VariableDeclarations)
-                        return statement;
-                    const variables = decls.variables.map(padded => {
-                        var _a, _b;
-                        const variable = padded.element;
-                        const initializer = (_a = variable.initializer) === null || _a === void 0 ? void 0 : _a.element;
-                        if ((0, module_bindings_1.requiredModule)(initializer) === undefined)
-                            return padded;
-                        const call = initializer;
-                        const specifier = call.arguments.elements[0];
-                        const literal = specifier.element;
-                        const quote = ((_b = literal.valueSource) !== null && _b !== void 0 ? _b : "'").charAt(0);
-                        const moved = Object.assign(Object.assign({}, literal), { value: hpagent_support_1.TARGET_MODULE, valueSource: `${quote}${hpagent_support_1.TARGET_MODULE}${quote}` });
-                        return Object.assign(Object.assign({}, padded), { element: Object.assign(Object.assign({}, variable), { name: renameBindings(variable.name, this.targetLocals), initializer: Object.assign(Object.assign({}, variable.initializer), { element: Object.assign(Object.assign({}, call), { arguments: Object.assign(Object.assign({}, call.arguments), { elements: [Object.assign(Object.assign({}, specifier), { element: moved })] }) }) }) }) });
-                    });
-                    return Object.assign(Object.assign({}, decls), { variables });
-                }
                 applyRewrite(n, site, rewrite) {
                     const argument = n.arguments.elements[0];
                     const proxy = Object.assign(Object.assign({}, rewrite.proxy), { prefix: rewrite.literal.prefix });
@@ -466,10 +782,16 @@ class ReplaceHpagent extends rewrite_1.Recipe {
                 }
                 withMembers(rewrite) {
                     const original = paddedMembers(rewrite.literal);
-                    const members = [...rewrite.members];
+                    const trailing = (padded) => padded.markers.markers.some(m => m.kind === java_1.J.Markers.TrailingComma);
+                    const members = rewrite.members.map((m, i) => i < rewrite.members.length - 1 && trailing(m)
+                        ? Object.assign(Object.assign({}, m), { markers: Object.assign(Object.assign({}, m.markers), { markers: m.markers.markers.filter(k => k.kind !== java_1.J.Markers.TrailingComma) }) }) : m);
                     if (members[0] !== original[0]) {
                         members[0] = Object.assign(Object.assign({}, members[0]), { element: Object.assign(Object.assign({}, 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] = Object.assign(Object.assign({}, members[members.length - 1]), { after: last.after, markers: last.markers });
+                    }
                     return Object.assign(Object.assign({}, rewrite.literal), { prefix: (0, java_1.space)(' '), body: Object.assign(Object.assign({}, rewrite.literal.body), { statements: members }) });
                 }
                 migratedCallee(clazz, site) {
@@ -481,6 +803,41 @@ class ReplaceHpagent extends rewrite_1.Recipe {
                     const local = (_a = this.targetLocals.get(site.local)) !== null && _a !== void 0 ? _a : site.local;
                     return Object.assign(Object.assign({}, clazz), { simpleName: local });
                 }
+                agentClass() {
+                    var _a;
+                    const local = [...this.adapterLocals].find(l => !this.stranded.has(l));
+                    return this.bindings.get(local) === undefined
+                        ? `${local}.${hpagent_support_1.TARGET_CLASS}`
+                        : (_a = this.targetLocals.get(local)) !== null && _a !== void 0 ? _a : local;
+                }
+                withAdapter(cu, p) {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        const typeScript = !isJavaScript(cu.sourcePath);
+                        const style = (0, code_style_1.detectCodeStyle)(yield rewrite_1.TreePrinters.print(cu));
+                        const sources = [];
+                        if (this.adapterNeeded)
+                            sources.push((0, hpagent_support_1.adapterSource)(this.adapterName, this.typeName, this.agentClass(), typeScript, style));
+                        if (typeScript) {
+                            sources.push(...(0, hpagent_support_1.adapterTypeSource)(this.typeNeeded ? this.typeName : undefined, this.requestTypeNeeded ? this.requestTypeName : undefined, module => builtinSpecifier(cu, module), style));
+                        }
+                        const prettier = (0, rewrite_1.findMarker)(cu, javascript_1.StyleKind.PrettierStyle) !== undefined;
+                        let result = cu;
+                        for (const { doc, code } of sources) {
+                            const parsed = yield new javascript_1.JavaScriptParser().parseOnly({
+                                text: `/*${doc}*/\n${code}\n`, sourcePath: typeScript ? 'adapter.ts' : 'adapter.js'
+                            });
+                            if (parsed.kind !== javascript_1.JS.Kind.CompilationUnit || parsed.statements.length !== 1)
+                                continue;
+                            const statement = parsed.statements[0];
+                            const parent = new rewrite_1.Cursor(result, this.cursor);
+                            let declaration = Object.assign(Object.assign({}, statement.element), { prefix: Object.assign(Object.assign({}, parsed.prefix), { whitespace: '\n\n' }) });
+                            if (prettier)
+                                declaration = yield (0, javascript_1.autoFormat)(declaration, p, undefined, parent);
+                            result = Object.assign(Object.assign({}, result), { statements: [...result.statements, Object.assign(Object.assign({}, statement), { element: declaration })] });
+                        }
+                        return result;
+                    });
+                }
             };
         });
     }
@@ -489,12 +846,12 @@ exports.ReplaceHpagent = ReplaceHpagent;
 __decorate([
     (0, rewrite_1.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
     })
 ], ReplaceHpagent.prototype, "migrateSpreadOptions", void 0);