@openrewrite/rewrite 8.68.0-20251204-054843 → 8.68.0-20251204-145030

package/src/javascript/search/find-dependency.ts

@@ -0,0 +1,303 @@
+/*
+ * Copyright 2025 the original author or authors.
+ * <p>
+ * Licensed under the Moderne Source Available License (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * https://docs.moderne.io/licensing/moderate-source-available-license
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {Option, Recipe} from "../../recipe";
+import {ExecutionContext} from "../../execution";
+import {TreeVisitor} from "../../visitor";
+import {Json, JsonVisitor} from "../../json";
+import {foundSearchResult} from "../../markers";
+import {
+    Dependency,
+    findNodeResolutionResult,
+    NodeResolutionResult,
+    ResolvedDependency
+} from "../node-resolution-result";
+import * as semver from "semver";
+import * as picomatch from "picomatch";
+
+/** Dependency section names in package.json */
+const DEPENDENCY_SECTIONS = new Set([
+    'dependencies',
+    'devDependencies',
+    'peerDependencies',
+    'optionalDependencies'
+]);
+
+/**
+ * Finds npm/Node.js dependencies declared in package.json.
+ * This recipe is commonly used as a precondition to limit the scope of other recipes
+ * to projects that use a specific dependency.
+ *
+ * The search result marker is placed on the specific dependency entry in package.json,
+ * allowing users to see exactly where the dependency is declared.
+ *
+ * When `onlyDirect` is false, this recipe also marks direct dependencies that
+ * transitively depend on the target package, helping answer "which of my dependencies
+ * brings in package X?".
+ */
+export interface FindDependencyOptions {
+    packageName: string;
+    version?: string;
+    onlyDirect?: boolean;
+}
+
+export class FindDependency extends Recipe {
+    readonly name = "org.openrewrite.javascript.dependencies.find-dependency";
+    readonly displayName = "Find Node.js dependency";
+    readonly description = "Finds dependencies in a project's `package.json`. " +
+        "Can find both direct dependencies and dependencies that transitively include the target package. " +
+        "This recipe is commonly used as a precondition for other recipes.";
+
+    @Option({
+        displayName: "Package name",
+        description: "The name of the npm package to find. Supports glob patterns.",
+        example: "lodash"
+    })
+    packageName!: string;
+
+    @Option({
+        displayName: "Version",
+        description: "An exact version number or semver selector used to select the version number. " +
+            "Leave empty to match any version.",
+        example: "^18.0.0",
+        required: false
+    })
+    version?: string;
+
+    @Option({
+        displayName: "Only direct dependencies",
+        description: "If true (default), only matches dependencies that directly match the package name. " +
+            "If false, also marks direct dependencies that have the target package as a transitive dependency.",
+        example: "true",
+        required: false
+    })
+    onlyDirect?: boolean;
+
+    constructor(options: FindDependencyOptions) {
+        super(options);
+    }
+
+    override instanceName(): string {
+        return `${this.displayName} \`${this.packageName}${this.version ? '@' + this.version : ''}\``;
+    }
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        const packageName = this.packageName;
+        const version = this.version;
+        // Default to true if not specified (only search direct dependencies)
+        const onlyDirect = this.onlyDirect ?? true;
+
+        // Create a picomatch matcher for the package name pattern
+        // For patterns without '/', use { contains: true } so that '*jest*' matches '@types/jest'
+        // (by default, '*' doesn't match '/' in glob patterns, but for package names this is more intuitive)
+        const matchOptions = packageName.includes('/') ? {} : { contains: true };
+        const matcher: picomatch.Matcher = picomatch.default
+            ? picomatch.default(packageName, matchOptions)
+            : (picomatch as any)(packageName, matchOptions);
+
+        return new class extends JsonVisitor<ExecutionContext> {
+            private resolution: NodeResolutionResult | undefined;
+            private isPackageJson: boolean = false;
+
+            protected override async visitDocument(document: Json.Document, ctx: ExecutionContext): Promise<Json | undefined> {
+                // Only process package.json files, not package-lock.json or other JSON files
+                const sourcePath = document.sourcePath;
+                this.isPackageJson = sourcePath.endsWith('package.json');
+
+                if (this.isPackageJson) {
+                    this.resolution = findNodeResolutionResult(document);
+                }
+
+                return this.isPackageJson && this.resolution ? super.visitDocument(document, ctx) : document;
+            }
+
+            protected override async visitMember(member: Json.Member, ctx: ExecutionContext): Promise<Json | undefined> {
+                // Check if we're inside a dependency section
+                const parentSection = this.getParentDependencySection();
+                if (!parentSection) {
+                    return super.visitMember(member, ctx);
+                }
+
+                // Get the package name from the member key
+                const depName = this.getMemberKeyName(member);
+                if (!depName) {
+                    return super.visitMember(member, ctx);
+                }
+
+                // Find the dependency in the resolution result
+                const dep = this.findDependencyByName(depName, parentSection);
+                if (!dep) {
+                    return super.visitMember(member, ctx);
+                }
+
+                // Check if this dependency matches directly
+                if (matcher(depName) && versionMatches(dep, version)) {
+                    return this.markDependency(member, ctx);
+                }
+
+                // If not only direct, check if this dependency has the target as a transitive dependency
+                if (!onlyDirect && dep.resolved) {
+                    if (hasTransitiveDependency(dep.resolved, matcher, version, new Set())) {
+                        return this.markDependency(member, ctx);
+                    }
+                }
+
+                return super.visitMember(member, ctx);
+            }
+
+            /**
+             * Marks the dependency key with a search result marker.
+             */
+            private async markDependency(member: Json.Member, ctx: ExecutionContext): Promise<Json.Member> {
+                const visitedMember = await super.visitMember(member, ctx) as Json.Member;
+                const markedKey = foundSearchResult(visitedMember.key.element);
+                return {
+                    ...visitedMember,
+                    key: {
+                        ...visitedMember.key,
+                        element: markedKey
+                    }
+                } as Json.Member;
+            }
+
+            /**
+             * Checks if the current member's parent is a dependency section object.
+             * Returns the section name if so, undefined otherwise.
+             */
+            private getParentDependencySection(): string | undefined {
+                // Walk up the cursor to find the parent member that contains this dependency
+                // Structure: Document > Object > Member("dependencies") > Object > Member("lodash")
+                let cursor = this.cursor.parent;
+                while (cursor) {
+                    const tree = cursor.value;
+                    if (tree && typeof tree === 'object' && 'kind' in tree) {
+                        if (tree.kind === Json.Kind.Member) {
+                            const memberKey = this.getMemberKeyName(tree as Json.Member);
+                            if (memberKey && DEPENDENCY_SECTIONS.has(memberKey)) {
+                                return memberKey;
+                            }
+                        }
+                    }
+                    cursor = cursor.parent;
+                }
+                return undefined;
+            }
+
+            /**
+             * Extracts the key name from a Json.Member
+             */
+            private getMemberKeyName(member: Json.Member): string | undefined {
+                const key = member.key.element;
+                if (key.kind === Json.Kind.Literal) {
+                    // Remove quotes from string literal
+                    const source = (key as Json.Literal).source;
+                    if (source.startsWith('"') && source.endsWith('"')) {
+                        return source.slice(1, -1);
+                    }
+                    return source;
+                } else if (key.kind === Json.Kind.Identifier) {
+                    return (key as Json.Identifier).name;
+                }
+                return undefined;
+            }
+
+            /**
+             * Finds a dependency by name in the appropriate section of the resolution result.
+             */
+            private findDependencyByName(name: string, section: string): Dependency | undefined {
+                if (!this.resolution) return undefined;
+
+                let deps: Dependency[] | undefined;
+                switch (section) {
+                    case 'dependencies':
+                        deps = this.resolution.dependencies;
+                        break;
+                    case 'devDependencies':
+                        deps = this.resolution.devDependencies;
+                        break;
+                    case 'peerDependencies':
+                        deps = this.resolution.peerDependencies;
+                        break;
+                    case 'optionalDependencies':
+                        deps = this.resolution.optionalDependencies;
+                        break;
+                }
+
+                return deps?.find(d => d.name === name);
+            }
+        };
+    }
+}
+
+/**
+ * Recursively checks if a resolved dependency has the target package as a transitive dependency.
+ */
+function hasTransitiveDependency(
+    resolved: ResolvedDependency,
+    matcher: picomatch.Matcher,
+    version: string | undefined,
+    visited: Set<string>
+): boolean {
+    // Avoid cycles
+    const key = `${resolved.name}@${resolved.version}`;
+    if (visited.has(key)) {
+        return false;
+    }
+    visited.add(key);
+
+    // Check all dependency types
+    const allDeps = [
+        ...(resolved.dependencies || []),
+        ...(resolved.devDependencies || []),
+        ...(resolved.peerDependencies || []),
+        ...(resolved.optionalDependencies || [])
+    ];
+
+    for (const dep of allDeps) {
+        // Check if this dependency matches the target
+        if (matcher(dep.name) && versionMatches(dep, version)) {
+            return true;
+        }
+
+        // Recursively check transitive dependencies
+        if (dep.resolved && hasTransitiveDependency(dep.resolved, matcher, version, visited)) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+function versionMatches(dep: Dependency, version: string | undefined): boolean {
+    if (!version) {
+        return true;
+    }
+    const resolved = dep.resolved;
+    if (!resolved) {
+        // If no resolved version available, we can't validate the version
+        return false;
+    }
+    return versionMatchesResolved(resolved, version);
+}
+
+function versionMatchesResolved(resolved: ResolvedDependency, version: string | undefined): boolean {
+    if (!version) {
+        return true;
+    }
+    const actualVersion = resolved.version;
+    // Use semver.satisfies to check if the actual version matches the constraint
+    return semver.satisfies(actualVersion, version);
+}

package/src/javascript/search/index.ts

@@ -1,2 +1,3 @@
+export * from './find-dependency';
 export * from './uses-method';
 export * from './uses-type';

package/src/json/print.ts

@@ -125,7 +125,7 @@ class JsonPrinter extends JsonVisitor<PrintOutputCapture> {
         }
     }
 
-    private jsonMarkerWrapper = (out: string): string => `/*~~${out}${out ? "~~" : ""}*/`;
+    private jsonMarkerWrapper = (out: string): string => `/*~~${out}${out ? "~~" : ""}>*/`;
 }
 
 TreePrinters.register(Json.Kind.Document, () => new JsonPrinter());

package/src/markers.ts

@@ -22,6 +22,12 @@ export const MarkersKind = {
     SearchResult: "org.openrewrite.marker.SearchResult",
     ParseExceptionResult: "org.openrewrite.ParseExceptionResult",
 
+    // Markup markers for errors, warnings, info, and debug messages
+    MarkupError: "org.openrewrite.marker.Markup$Error",
+    MarkupWarn: "org.openrewrite.marker.Markup$Warn",
+    MarkupInfo: "org.openrewrite.marker.Markup$Info",
+    MarkupDebug: "org.openrewrite.marker.Markup$Debug",
+
     /**
      * A generic marker that is sent/received as a bare map because the type hasn't been
      * defined in both Java and JavaScript.
@@ -65,6 +71,60 @@ export function findMarker<T extends Marker>(
     );
 }
 
+/**
+ * Replaces a marker in a Markers collection with a new marker.
+ * If the old marker is not found, the new marker is added.
+ *
+ * @param markers The markers collection to update
+ * @param oldMarker The marker to replace (matched by id)
+ * @param newMarker The new marker to insert
+ * @returns A new Markers object with the replacement applied
+ */
+export function replaceMarker(markers: Markers, oldMarker: Marker, newMarker: Marker): Markers {
+    const newMarkers = markers.markers.map(m =>
+        m.id === oldMarker.id ? newMarker : m
+    );
+
+    // If old marker wasn't found, add the new one
+    if (!markers.markers.some(m => m.id === oldMarker.id)) {
+        newMarkers.push(newMarker);
+    }
+
+    return {
+        ...markers,
+        markers: newMarkers
+    };
+}
+
+/**
+ * Replaces the first marker with the same kind as the new marker, or adds it if not found.
+ * This is useful when there's typically only one marker of each kind.
+ *
+ * @param markers The markers collection to update
+ * @param newMarker The new marker to insert (its kind is used to find the marker to replace)
+ * @returns A new Markers object with the replacement applied
+ */
+export function replaceMarkerByKind(markers: Markers, newMarker: Marker): Markers {
+    let found = false;
+    const newMarkers = markers.markers.map(m => {
+        if (!found && m.kind === newMarker.kind) {
+            found = true;
+            return newMarker;
+        }
+        return m;
+    });
+
+    // If marker with kind wasn't found, add the new one
+    if (!found) {
+        newMarkers.push(newMarker);
+    }
+
+    return {
+        ...markers,
+        markers: newMarkers
+    };
+}
+
 export const emptyMarkers: Markers = asRef({
     kind: MarkersKind.Markers,
     id: randomId(),
@@ -101,3 +161,89 @@ export interface ParseExceptionResult extends Marker {
     readonly message: string
     readonly treeType?: string;
 }
+
+/**
+ * Base interface for Markup markers that attach messages to AST nodes.
+ * Used for errors, warnings, info, and debug messages.
+ */
+export interface Markup extends Marker {
+    readonly message: string;
+    readonly detail?: string;
+}
+
+export interface MarkupError extends Markup {
+    readonly kind: typeof MarkersKind.MarkupError;
+}
+
+export interface MarkupWarn extends Markup {
+    readonly kind: typeof MarkersKind.MarkupWarn;
+}
+
+export interface MarkupInfo extends Markup {
+    readonly kind: typeof MarkersKind.MarkupInfo;
+}
+
+export interface MarkupDebug extends Markup {
+    readonly kind: typeof MarkersKind.MarkupDebug;
+}
+
+/**
+ * Attaches an error marker to a tree node.
+ */
+export function markupError<T extends { markers: Markers }>(t: T, message: string, detail?: string): T {
+    return addMarkup(t, {
+        kind: MarkersKind.MarkupError,
+        id: randomId(),
+        message,
+        detail
+    });
+}
+
+/**
+ * Attaches a warning marker to a tree node.
+ */
+export function markupWarn<T extends { markers: Markers }>(t: T, message: string, detail?: string): T {
+    return addMarkup(t, {
+        kind: MarkersKind.MarkupWarn,
+        id: randomId(),
+        message,
+        detail
+    });
+}
+
+/**
+ * Attaches an info marker to a tree node.
+ */
+export function markupInfo<T extends { markers: Markers }>(t: T, message: string, detail?: string): T {
+    return addMarkup(t, {
+        kind: MarkersKind.MarkupInfo,
+        id: randomId(),
+        message,
+        detail
+    });
+}
+
+/**
+ * Attaches a debug marker to a tree node.
+ */
+export function markupDebug<T extends { markers: Markers }>(t: T, message: string, detail?: string): T {
+    return addMarkup(t, {
+        kind: MarkersKind.MarkupDebug,
+        id: randomId(),
+        message,
+        detail
+    });
+}
+
+/**
+ * Helper to add a markup marker to a tree node.
+ */
+function addMarkup<T extends { markers: Markers }>(t: T, markup: Markup): T {
+    return {
+        ...t,
+        markers: {
+            ...t.markers,
+            markers: [...t.markers.markers, markup]
+        }
+    } as T;
+}

package/src/print.ts

@@ -35,7 +35,6 @@ export namespace MarkerPrinter {
                 let searchResult = marker as SearchResult;
                 return commentWrapper(searchResult.description == null ? "" : "(" + searchResult.description + ")");
             } else if (marker.kind.startsWith("org.openrewrite.marker.Markup$")) {
-                // TODO add markup marker types
                 return commentWrapper("(" + (marker as any).message + ")");
             }
             return "";

package/src/recipe.ts

@@ -171,12 +171,12 @@ export abstract class ScanningRecipe<P> extends Recipe {
             }
 
             async visit<R extends Tree>(tree: Tree, ctx: ExecutionContext, parent?: Cursor): Promise<R | undefined> {
-                return (await this.delegateForCtx(ctx)).visit(tree, ctx, parent);
+                return (await this.delegateForCtx(ctx, parent)).visit(tree, ctx, parent);
             }
 
-            private async delegateForCtx(ctx: ExecutionContext) {
+            private async delegateForCtx(ctx: ExecutionContext, parent?: Cursor) {
                 if (!this.delegate) {
-                    this.delegate = await editorWithContext(this.cursor, ctx);
+                    this.delegate = await editorWithContext(parent ?? this.cursor, ctx);
                 }
                 return this.delegate;
             }

package/src/rpc/index.ts

@@ -16,7 +16,7 @@
 import {Checksum, FileAttributes, TreeKind} from "../tree";
 import {RpcCodecs, RpcReceiveQueue, RpcSendQueue} from "./queue";
 import {createDraft, finishDraft} from "immer";
-import {Markers, MarkersKind, SearchResult} from "../markers";
+import {Markers, MarkersKind, SearchResult, MarkupError, MarkupWarn, MarkupInfo, MarkupDebug} from "../markers";
 
 export * from "./queue"
 export * from "../reference"
@@ -88,3 +88,67 @@ RpcCodecs.registerCodec(MarkersKind.SearchResult, {
         await q.getAndSend(after, a => a.description);
     }
 });
+
+RpcCodecs.registerCodec(MarkersKind.MarkupError, {
+    async rpcReceive(before: MarkupError, q: RpcReceiveQueue): Promise<MarkupError> {
+        const draft = createDraft(before);
+        draft.id = await q.receive(before.id);
+        draft.message = await q.receive(before.message);
+        draft.detail = await q.receive(before.detail);
+        return finishDraft(draft);
+    },
+
+    async rpcSend(after: MarkupError, q: RpcSendQueue): Promise<void> {
+        await q.getAndSend(after, a => a.id);
+        await q.getAndSend(after, a => a.message);
+        await q.getAndSend(after, a => a.detail);
+    }
+});
+
+RpcCodecs.registerCodec(MarkersKind.MarkupWarn, {
+    async rpcReceive(before: MarkupWarn, q: RpcReceiveQueue): Promise<MarkupWarn> {
+        const draft = createDraft(before);
+        draft.id = await q.receive(before.id);
+        draft.message = await q.receive(before.message);
+        draft.detail = await q.receive(before.detail);
+        return finishDraft(draft);
+    },
+
+    async rpcSend(after: MarkupWarn, q: RpcSendQueue): Promise<void> {
+        await q.getAndSend(after, a => a.id);
+        await q.getAndSend(after, a => a.message);
+        await q.getAndSend(after, a => a.detail);
+    }
+});
+
+RpcCodecs.registerCodec(MarkersKind.MarkupInfo, {
+    async rpcReceive(before: MarkupInfo, q: RpcReceiveQueue): Promise<MarkupInfo> {
+        const draft = createDraft(before);
+        draft.id = await q.receive(before.id);
+        draft.message = await q.receive(before.message);
+        draft.detail = await q.receive(before.detail);
+        return finishDraft(draft);
+    },
+
+    async rpcSend(after: MarkupInfo, q: RpcSendQueue): Promise<void> {
+        await q.getAndSend(after, a => a.id);
+        await q.getAndSend(after, a => a.message);
+        await q.getAndSend(after, a => a.detail);
+    }
+});
+
+RpcCodecs.registerCodec(MarkersKind.MarkupDebug, {
+    async rpcReceive(before: MarkupDebug, q: RpcReceiveQueue): Promise<MarkupDebug> {
+        const draft = createDraft(before);
+        draft.id = await q.receive(before.id);
+        draft.message = await q.receive(before.message);
+        draft.detail = await q.receive(before.detail);
+        return finishDraft(draft);
+    },
+
+    async rpcSend(after: MarkupDebug, q: RpcSendQueue): Promise<void> {
+        await q.getAndSend(after, a => a.id);
+        await q.getAndSend(after, a => a.message);
+        await q.getAndSend(after, a => a.detail);
+    }
+});

package/src/rpc/request/generate.ts

@@ -53,7 +53,7 @@ export class Generate {
                             cursor = rootCursor();
                             recipeCursors.set(recipe, cursor);
                         }
-                        const ctx = getObject(request.p) as ExecutionContext;
+                        const ctx = await getObject(request.p) as ExecutionContext;
                         const acc = recipe.accumulator(cursor, ctx);
                         const generated = await recipe.generate(acc, ctx)
 

package/src/rpc/request/get-languages.ts

@@ -13,7 +13,8 @@ export class GetLanguages {
                     const languages = [
                         "org.openrewrite.text.PlainText",
                         "org.openrewrite.json.tree.Json$Document",
-                        "org.openrewrite.java.tree.J$CompilationUnit",
+                        // TODO Support for Javadoc comments is not yet implemented
+                        // "org.openrewrite.java.tree.J$CompilationUnit",
                         "org.openrewrite.javascript.tree.JS$CompilationUnit",
                     ];
                     context.target = '';

package/src/rpc/request/visit.ts

@@ -15,7 +15,7 @@
  */
 import * as rpc from "vscode-jsonrpc/node";
 import {Recipe, ScanningRecipe} from "../../recipe";
-import {Cursor, rootCursor, Tree} from "../../tree";
+import {Cursor, rootCursor, SourceFile, Tree} from "../../tree";
 import {TreeVisitor} from "../../visitor";
 import {ExecutionContext} from "../../execution";
 import {withMetrics, extractSourcePath} from "./metrics";
@@ -24,6 +24,10 @@ export interface VisitResponse {
     modified: boolean
 }
 
+// Tracks the last phase (scan or edit) for each recipe to detect cycle transitions
+type RecipePhase = 'scan' | 'edit';
+const recipePhases: WeakMap<Recipe, RecipePhase> = new WeakMap();
+
 export class Visit {
     constructor(private readonly visitor: string,
                 private readonly sourceFileType: string,
@@ -77,13 +81,27 @@ export class Visit {
             if (!recipe) {
                 throw new Error(`No scanning recipe found for key: ${recipeKey}`);
             }
+            // If we're transitioning from edit back to scan, this is a new cycle.
+            // Clear the cursor so a fresh accumulator is created.
+            if (recipePhases.get(recipe) === 'edit') {
+                recipeCursors.delete(recipe);
+            }
+            recipePhases.set(recipe, 'scan');
+
             let cursor = recipeCursors.get(recipe);
             if (!cursor) {
                 cursor = rootCursor();
                 recipeCursors.set(recipe, cursor);
             }
             const acc = recipe.accumulator(cursor, p);
+
             return new class extends TreeVisitor<any, ExecutionContext> {
+                // Delegate isAcceptable to the scanner visitor
+                // This ensures we only process source files the scanner can handle
+                async isAcceptable(sourceFile: SourceFile, ctx: ExecutionContext): Promise<boolean> {
+                    return (await recipe.scanner(acc)).isAcceptable(sourceFile, ctx);
+                }
+
                 protected async preVisit(tree: any, ctx: ExecutionContext): Promise<any> {
                     await (await recipe.scanner(acc)).visit(tree, ctx);
                     this.stopAfterPreVisit();
@@ -96,6 +114,19 @@ export class Visit {
             if (!recipe) {
                 throw new Error(`No editing recipe found for key: ${recipeKey}`);
             }
+            recipePhases.set(recipe, 'edit');
+
+            // For ScanningRecipe, we need to use the same cursor that was used during scanning
+            // to retrieve the accumulator that was stored there
+            if (recipe instanceof ScanningRecipe) {
+                let cursor = recipeCursors.get(recipe);
+                if (!cursor) {
+                    cursor = rootCursor();
+                    recipeCursors.set(recipe, cursor);
+                }
+                const acc = recipe.accumulator(cursor, p);
+                return recipe.editorWithData(acc);
+            }
             return await recipe.editor();
         } else {
             return Reflect.construct(

package/src/run.ts

@@ -82,14 +82,14 @@ export async function scheduleRun(recipe: Recipe, before: SourceFile[], ctx: Exe
     const changeset: Result[] = [];
 
     for (const b of before) {
-        const editedB = await recurseRecipeList(recipe, b, async (recipe, b2) => (await recipe.editor()).visit(b2, ctx));
+        const editedB = await recurseRecipeList(recipe, b, async (recipe, b2) => (await recipe.editor()).visit(b2, ctx, cursor));
         if (editedB !== b) {
             changeset.push(new Result(b, editedB));
         }
     }
 
     for (const g of generated) {
-        const editedG = await recurseRecipeList(recipe, g, async (recipe, g2) => (await recipe.editor()).visit(g2, ctx));
+        const editedG = await recurseRecipeList(recipe, g, async (recipe, g2) => (await recipe.editor()).visit(g2, ctx, cursor));
         if (editedG) {
             changeset.push(new Result(undefined, editedG));
         }