@openrewrite/rewrite 8.69.0-20251206-160244 → 8.69.0-20251207-092603

package/src/cli/rewrite.ts

@@ -15,12 +15,13 @@
  * limitations under the License.
  */
 import {Command} from 'commander';
+import * as fs from 'fs';
 import * as fsp from 'fs/promises';
 import * as path from 'path';
 import {spawn} from 'child_process';
-import {RecipeRegistry} from '../recipe';
+import {Recipe, RecipeRegistry} from '../recipe';
 import {ExecutionContext} from '../execution';
-import {scheduleRunStreaming} from '../run';
+import {ProgressCallback, scheduleRunStreaming} from '../run';
 import {TreePrinters} from '../print';
 import {activate} from '../index';
 import {
@@ -28,11 +29,13 @@ import {
     discoverFiles,
     findRecipe,
     installRecipePackage,
+    isAcceptedFile,
     loadLocalRecipes,
-    parseFiles,
+    parseFilesStreaming,
     parseRecipeOptions,
     parseRecipeSpec
 } from './cli-utils';
+import {ValidateParsingRecipe} from './validate-parsing-recipe';
 
 const isTTY = process.stdout.isTTY ?? false;
 const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
@@ -83,21 +86,80 @@ require('v8').setFlagsFromString('--stack-size=8000');
 
 const DEFAULT_RECIPE_DIR = path.join(process.env.HOME || '', '.rewrite', 'javascript', 'recipes');
 
+/**
+ * Check if a directory is a git repository root.
+ */
+function isGitRoot(dir: string): boolean {
+    return fs.existsSync(path.join(dir, '.git'));
+}
+
+/**
+ * Find the project root by scanning upward for a directory containing package.json.
+ * Stops at git repository root or filesystem root.
+ * Returns the starting directory if no package.json is found.
+ */
+function findProjectRoot(startDir: string): string {
+    let dir = path.resolve(startDir);
+    while (true) {
+        const packageJsonPath = path.join(dir, 'package.json');
+        if (fs.existsSync(packageJsonPath)) {
+            return dir;
+        }
+        // Stop at git root - don't scan beyond the repository
+        if (isGitRoot(dir)) {
+            return dir;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir) {
+            // Reached filesystem root, return original directory
+            return path.resolve(startDir);
+        }
+        dir = parent;
+    }
+}
+
 interface CliOptions {
-    dryRun: boolean;
+    apply: boolean;
+    list: boolean;
     recipeDir?: string;
     option: string[];
     verbose: boolean;
     debug: boolean;
 }
 
+/**
+ * Convert a project-root-relative path to a CWD-relative path for display.
+ */
+function toCwdRelative(sourcePath: string, projectRoot: string): string {
+    const absolutePath = path.join(projectRoot, sourcePath);
+    return path.relative(process.cwd(), absolutePath) || '.';
+}
+
+/**
+ * Transform diff output to use CWD-relative paths in headers.
+ */
+function transformDiffPaths(diff: string, projectRoot: string): string {
+    return diff.replace(
+        /^(---|\+\+\+) (.+)$/gm,
+        (_match, prefix, filePath) => {
+            if (filePath) {
+                const cwdRelative = toCwdRelative(filePath, projectRoot);
+                return `${prefix} ${cwdRelative}`;
+            }
+            return _match;
+        }
+    );
+}
+
 async function main() {
     const program = new Command();
     program
         .name('rewrite')
         .description('Run OpenRewrite recipes on your codebase')
         .argument('<recipe>', 'Recipe to run in format "package:recipe" (e.g., "@openrewrite/recipes-nodejs:replace-deprecated-slice")')
-        .option('-n, --dry-run', 'Show what changes would be made without applying them', false)
+        .argument('[paths...]', 'Files or directories to process (defaults to project root)')
+        .option('--apply', 'Apply changes to files (default is dry-run showing diffs)', false)
+        .option('-l, --list', 'Only list paths of files that would be changed', false)
         .option('-d, --recipe-dir <dir>', 'Directory for recipe installation', DEFAULT_RECIPE_DIR)
         .option('-o, --option <option...>', 'Recipe options in format "key=value"', [])
         .option('-v, --verbose', 'Enable verbose output', false)
@@ -105,6 +167,7 @@ async function main() {
         .parse();
 
     const recipeArg = program.args[0];
+    const pathArgs = program.args.slice(1);
     const opts = program.opts() as CliOptions;
     opts.option = opts.option || [];
 
@@ -118,47 +181,59 @@ async function main() {
         return;
     }
 
-    // Parse recipe specification
-    const recipeSpec = parseRecipeSpec(recipeArg);
-    if (!recipeSpec) {
-        console.error(`Invalid recipe format: ${recipeArg}`);
-        console.error('Expected format: "package:recipe" (e.g., "@openrewrite/recipes-nodejs:replace-deprecated-slice")');
-        process.exit(1);
-    }
+    // Handle special built-in recipes
+    let recipe: Recipe;
+    let validateParsingRecipe: ValidateParsingRecipe | undefined;
 
-    if (opts.verbose) {
-        console.log(`Package: ${recipeSpec.packageName}`);
-        console.log(`Recipe: ${recipeSpec.recipeName}`);
-    }
+    if (recipeArg === 'validate-parsing') {
+        // Special recipe to validate parsing and check idempotence
+        validateParsingRecipe = new ValidateParsingRecipe();
+        recipe = validateParsingRecipe;
+    } else {
+        // Parse recipe specification
+        const recipeSpec = parseRecipeSpec(recipeArg);
+        if (!recipeSpec) {
+            console.error(`Invalid recipe format: ${recipeArg}`);
+            console.error('Expected format: "package:recipe" (e.g., "@openrewrite/recipes-nodejs:replace-deprecated-slice")');
+            console.error('Or use "validate-parsing" to check for parse errors and idempotence.');
+            process.exit(1);
+        }
 
-    // Parse recipe options
-    const recipeOptions = parseRecipeOptions(opts.option);
-    if (opts.verbose && Object.keys(recipeOptions).length > 0) {
-        console.log(`Options: ${JSON.stringify(recipeOptions)}`);
-    }
+        if (opts.verbose) {
+            console.log(`Package: ${recipeSpec.packageName}`);
+            console.log(`Recipe: ${recipeSpec.recipeName}`);
+        }
+
+        // Parse recipe options
+        const recipeOptions = parseRecipeOptions(opts.option);
+        if (opts.verbose && Object.keys(recipeOptions).length > 0) {
+            console.log(`Options: ${JSON.stringify(recipeOptions)}`);
+        }
 
-    // Set up recipe registry
-    const registry = new RecipeRegistry();
+        // Set up recipe registry
+        const registry = new RecipeRegistry();
 
-    // Register built-in recipes
-    await activate(registry);
+        // Register built-in recipes
+        await activate(registry);
 
-    // Load recipes from local path or install from NPM
-    try {
-        if (recipeSpec.isLocalPath) {
-            await loadLocalRecipes(recipeSpec.packageName, registry, opts.verbose);
-        } else {
-            await installRecipePackage(recipeSpec.packageName, opts.recipeDir || DEFAULT_RECIPE_DIR, registry, opts.verbose);
+        // Load recipes from local path or install from NPM
+        try {
+            if (recipeSpec.isLocalPath) {
+                await loadLocalRecipes(recipeSpec.packageName, registry, opts.verbose);
+            } else {
+                await installRecipePackage(recipeSpec.packageName, opts.recipeDir || DEFAULT_RECIPE_DIR, registry, opts.verbose);
+            }
+        } catch (e: any) {
+            console.error(`Failed to load recipes: ${e.message}`);
+            process.exit(1);
         }
-    } catch (e: any) {
-        console.error(`Failed to load recipes: ${e.message}`);
-        process.exit(1);
-    }
 
-    // Find the recipe
-    const recipe = findRecipe(registry, recipeSpec.recipeName, recipeOptions);
-    if (!recipe) {
-        process.exit(1);
+        // Find the recipe
+        const foundRecipe = findRecipe(registry, recipeSpec.recipeName, recipeOptions);
+        if (!foundRecipe) {
+            process.exit(1);
+        }
+        recipe = foundRecipe;
     }
 
     if (opts.verbose) {
@@ -166,63 +241,115 @@ async function main() {
     }
 
     const spinner = new Spinner();
-    const projectRoot = process.cwd();
 
-    // Discover source files
-    spinner.start('Discovering source files...');
-    const sourceFiles = await discoverFiles(projectRoot, opts.verbose);
+    // Determine paths to process and project root
+    let targetPaths: string[];
+    let projectRoot: string;
+
+    if (pathArgs.length > 0) {
+        // Explicit paths provided - find project root and validate they're all in the same project
+        targetPaths = pathArgs.map(p => path.resolve(p));
+        const projectRoots = new Set<string>();
+        for (const targetPath of targetPaths) {
+            const pathDir = fs.statSync(targetPath).isDirectory() ? targetPath : path.dirname(targetPath);
+            projectRoots.add(findProjectRoot(pathDir));
+        }
+
+        if (projectRoots.size > 1) {
+            console.error('Error: Specified paths belong to different projects:');
+            for (const root of projectRoots) {
+                console.error(`  - ${root}`);
+            }
+            console.error('\nAll paths must be within the same project (share a common package.json root).');
+            process.exit(1);
+        }
+
+        projectRoot = projectRoots.values().next().value!;
+
+        if (opts.verbose) {
+            if (targetPaths.length > 1) {
+                console.log(`Processing ${targetPaths.length} paths`);
+            }
+            console.log(`Project root: ${projectRoot}`);
+        }
+    } else {
+        // No paths provided - find project root from CWD and process entire project
+        projectRoot = findProjectRoot(process.cwd());
+        targetPaths = [projectRoot];
+
+        if (opts.verbose) {
+            console.log(`Processing entire project: ${projectRoot}`);
+        }
+    }
+
+    // Discover source files from all specified paths
+    if (!opts.verbose) {
+        spinner.start('Discovering source files...');
+    }
+    const sourceFiles: string[] = [];
+    for (const targetPath of targetPaths) {
+        const stat = await fsp.stat(targetPath);
+        if (stat.isDirectory()) {
+            const files = await discoverFiles(targetPath, opts.verbose);
+            sourceFiles.push(...files);
+        } else if (stat.isFile() && isAcceptedFile(targetPath)) {
+            sourceFiles.push(targetPath);
+        }
+    }
+    // Remove duplicates (in case of overlapping paths)
+    const uniqueSourceFiles = [...new Set(sourceFiles)];
     spinner.stop();
 
-    if (sourceFiles.length === 0) {
+    if (uniqueSourceFiles.length === 0) {
         console.log('No source files found to process.');
         return;
     }
 
     if (opts.verbose) {
-        console.log(`Found ${sourceFiles.length} source files`);
+        console.log(`Found ${uniqueSourceFiles.length} source files`);
     }
 
-    // Parse all source files
-    spinner.start(`Parsing ${sourceFiles.length} files...`);
-    const parsedFiles = await parseFiles(sourceFiles, projectRoot, opts.verbose, (current, total, filePath) => {
-        spinner.update(`Parsing [${current}/${total}] ${filePath}`);
-    });
-    spinner.stop();
-
-    if (parsedFiles.length === 0) {
-        console.log('No files could be parsed.');
-        return;
+    // Set project root for validate-parsing recipe if active
+    if (validateParsingRecipe) {
+        validateParsingRecipe.setProjectRoot(projectRoot);
     }
 
-    // Run the recipe with streaming output
+    // Create streaming parser - files are parsed on-demand as they're consumed
+    const totalFiles = uniqueSourceFiles.length;
+    const sourceFileStream = parseFilesStreaming(uniqueSourceFiles, projectRoot, {
+        verbose: opts.verbose
+    });
+
+    // Run the recipe with streaming output - for non-scanning recipes,
+    // parsing and processing happen concurrently without collecting all files first
     const ctx = new ExecutionContext();
     let changeCount = 0;
     let processedCount = 0;
-    const totalFiles = parsedFiles.length;
 
-    spinner.start(`Running recipe on ${totalFiles} files...`);
+    // Progress callback for spinner updates during all phases (disabled in verbose mode)
+    const onProgress: ProgressCallback | undefined = opts.verbose ? undefined : (phase, current, total, sourcePath) => {
+        const totalStr = total > 0 ? total : totalFiles;
+        const phaseLabel = phase.charAt(0).toUpperCase() + phase.slice(1);
+        spinner.update(`${phaseLabel} [${current}/${totalStr}] ${sourcePath}`);
+    };
+
+    if (!opts.verbose) {
+        spinner.start(`Processing ${totalFiles} files...`);
+    }
 
-    for await (const result of scheduleRunStreaming(recipe, parsedFiles, ctx)) {
+    for await (const result of scheduleRunStreaming(recipe, sourceFileStream, ctx, onProgress)) {
         processedCount++;
         const currentPath = result.after?.sourcePath ?? result.before?.sourcePath ?? '';
-        spinner.update(`Processing [${processedCount}/${totalFiles}] ${currentPath}`);
 
         const statusMsg = `Processing [${processedCount}/${totalFiles}] ${currentPath}`;
 
-        if (opts.dryRun) {
-            // Print colorized diff immediately (skip empty diffs)
-            const diff = await result.diff();
-            const hasChanges = diff.split('\n').some(line =>
-                (line.startsWith('+') || line.startsWith('-')) &&
-                !line.startsWith('+++') && !line.startsWith('---')
-            );
-            if (hasChanges) {
-                changeCount++;
-                spinner.stop();
-                console.log(colorizeDiff(diff));
-                spinner.start(statusMsg);
-            }
-        } else {
+        // Skip unchanged files - first check object identity (fast path),
+        // then check actual diff content for files where visitor returned new object
+        if (result.before === result.after) {
+            continue; // Definitely unchanged
+        }
+
+        if (opts.apply) {
             // Apply changes immediately
             if (result.after) {
                 const filePath = path.join(projectRoot, result.after.sourcePath);
@@ -233,32 +360,64 @@ async function main() {
                 await fsp.writeFile(filePath, content);
 
                 changeCount++;
-                spinner.stop();
+                if (!opts.verbose) spinner.stop();
+                const displayPath = toCwdRelative(result.after.sourcePath, projectRoot);
                 if (result.before) {
-                    console.log(`  Modified: ${result.after.sourcePath}`);
+                    console.log(`  Modified: ${displayPath}`);
                 } else {
-                    console.log(`  Created: ${result.after.sourcePath}`);
+                    console.log(`  Created: ${displayPath}`);
                 }
-                spinner.start(statusMsg);
+                if (!opts.verbose) spinner.start(statusMsg);
             } else if (result.before) {
                 const filePath = path.join(projectRoot, result.before.sourcePath);
                 await fsp.unlink(filePath);
                 changeCount++;
-                spinner.stop();
-                console.log(`  Deleted: ${result.before.sourcePath}`);
-                spinner.start(statusMsg);
+                if (!opts.verbose) spinner.stop();
+                console.log(`  Deleted: ${toCwdRelative(result.before.sourcePath, projectRoot)}`);
+                if (!opts.verbose) spinner.start(statusMsg);
+            }
+        } else {
+            // Dry-run mode: show diff or just list paths
+            const diff = await result.diff();
+            const hasChanges = diff.split('\n').some(line =>
+                (line.startsWith('+') || line.startsWith('-')) &&
+                !line.startsWith('+++') && !line.startsWith('---')
+            );
+            if (hasChanges) {
+                changeCount++;
+                if (!opts.verbose) spinner.stop();
+                if (opts.list) {
+                    // Just list the path
+                    const displayPath = toCwdRelative(
+                        result.after?.sourcePath ?? result.before?.sourcePath ?? '',
+                        projectRoot
+                    );
+                    console.log(displayPath);
+                } else {
+                    // Show the diff with CWD-relative paths
+                    console.log(colorizeDiff(transformDiffPaths(diff, projectRoot)));
+                }
+                if (!opts.verbose) spinner.start(statusMsg);
             }
         }
     }
 
-    spinner.stop();
+    if (!opts.verbose) spinner.stop();
+
+    // For validate-parsing recipe, check for errors and exit accordingly
+    if (validateParsingRecipe) {
+        if (!validateParsingRecipe.hasErrors) {
+            console.log('All files parsed successfully.');
+        }
+        process.exit(validateParsingRecipe.hasErrors ? 1 : 0);
+    }
 
     if (changeCount === 0) {
         console.log('No changes to make.');
-    } else if (opts.dryRun) {
-        console.log(`\n${changeCount} file(s) would be changed.`);
-    } else {
+    } else if (opts.apply) {
         console.log(`\n${changeCount} file(s) changed.`);
+    } else if (!opts.list) {
+        console.log(`\n${changeCount} file(s) would be changed. Run with --apply to apply changes.`);
     }
 }
 

package/src/cli/validate-parsing-recipe.ts

@@ -0,0 +1,114 @@
+/*
+ * 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/moderne-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 {Recipe} from '../recipe';
+import {TreeVisitor} from '../visitor';
+import {ExecutionContext} from '../execution';
+import {SourceFile, Tree} from '../tree';
+import {isParseError} from '../parse-error';
+import {MarkersKind, ParseExceptionResult} from '../markers';
+import {TreePrinters} from '../print';
+import {createTwoFilesPatch} from 'diff';
+import * as fs from 'fs';
+import * as path from 'path';
+
+/**
+ * A recipe that validates parsing by:
+ * 1. Reporting parse errors to stderr
+ * 2. Checking parse-to-print idempotence and showing diffs for failures
+ *
+ * Use this recipe to validate that the parser correctly handles your codebase.
+ */
+export class ValidateParsingRecipe extends Recipe {
+    name = 'org.openrewrite.validate-parsing';
+    displayName = 'Validate parsing';
+    description = 'Validates that all source files parse correctly and that parse-to-print is idempotent. Reports parse errors and shows diffs for idempotence failures.';
+
+    private projectRoot: string = process.cwd();
+    private parseErrorCount = 0;
+    private idempotenceFailureCount = 0;
+
+    setProjectRoot(root: string): this {
+        this.projectRoot = root;
+        return this;
+    }
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        const recipe = this;
+        return new class extends TreeVisitor<Tree, ExecutionContext> {
+            async visit<R extends Tree>(tree: Tree | undefined, ctx: ExecutionContext): Promise<R | undefined> {
+                if (!tree) return undefined;
+
+                const sourceFile = tree as SourceFile;
+
+                // Check for parse errors
+                if (isParseError(sourceFile)) {
+                    const parseException = sourceFile.markers.markers.find(
+                        m => m.kind === MarkersKind.ParseExceptionResult
+                    ) as ParseExceptionResult | undefined;
+                    const message = parseException?.message ?? 'Unknown parse error';
+                    console.error(`Parse error in ${sourceFile.sourcePath}: ${message}`);
+                    recipe.parseErrorCount++;
+                    return tree as R;
+                }
+
+                // Check parse-to-print idempotence
+                try {
+                    const printed = await TreePrinters.print(sourceFile);
+                    const originalPath = path.join(recipe.projectRoot, sourceFile.sourcePath);
+                    const original = fs.readFileSync(originalPath, 'utf-8');
+
+                    if (printed !== original) {
+                        recipe.idempotenceFailureCount++;
+                        console.error(`Parse-to-print idempotence failure in ${sourceFile.sourcePath}:`);
+
+                        // Generate and print diff
+                        const diff = createTwoFilesPatch(
+                            sourceFile.sourcePath,
+                            sourceFile.sourcePath,
+                            original,
+                            printed,
+                            'original',
+                            'printed',
+                            {context: 3}
+                        );
+                        console.error(diff);
+                    }
+                } catch (e: any) {
+                    recipe.idempotenceFailureCount++;
+                    console.error(`Failed to check idempotence for ${sourceFile.sourcePath}: ${e.message}`);
+                }
+
+                return tree as R;
+            }
+        };
+    }
+
+    async onComplete(_ctx: ExecutionContext): Promise<void> {
+        if (this.parseErrorCount > 0 || this.idempotenceFailureCount > 0) {
+            console.error('');
+            if (this.parseErrorCount > 0) {
+                console.error(`${this.parseErrorCount} file(s) had parse errors.`);
+            }
+            if (this.idempotenceFailureCount > 0) {
+                console.error(`${this.idempotenceFailureCount} file(s) had parse-to-print idempotence failures.`);
+            }
+        }
+    }
+
+    get hasErrors(): boolean {
+        return this.parseErrorCount > 0 || this.idempotenceFailureCount > 0;
+    }
+}

package/src/javascript/format.ts

@@ -464,8 +464,13 @@ export class SpacesVisitor<P> extends JavaScriptVisitor<P> {
         }
         return produceAsync(ret, async draft => {
             if (draft.initializer) {
-                draft.initializer.before.whitespace = this.style.aroundOperators.assignment ? " " : "";
-                draft.initializer.element.prefix.whitespace = this.style.aroundOperators.assignment ? " " : "";
+                // Preserve newlines - only modify if no newlines present
+                if (!draft.initializer.before.whitespace.includes("\n")) {
+                    draft.initializer.before.whitespace = this.style.aroundOperators.assignment ? " " : "";
+                }
+                if (!draft.initializer.element.prefix.whitespace.includes("\n")) {
+                    draft.initializer.element.prefix.whitespace = this.style.aroundOperators.assignment ? " " : "";
+                }
             }
         });
     }

package/src/javascript/parser.ts

@@ -1764,7 +1764,9 @@ export class JavaScriptParserVisitor {
             prefix: this.prefix(node),
             markers: emptyMarkers,
             head: this.visit(node.head),
-            spans: node.templateSpans.map(s => this.rightPadded(this.visit(s), this.suffix(s))),
+            // Use emptySpace for the last span's after - any trailing whitespace belongs to the outer context
+            spans: node.templateSpans.map((s, i, arr) =>
+                this.rightPadded(this.visit(s), i === arr.length - 1 ? emptySpace : this.suffix(s))),
             type: this.mapType(node)
         }
     }
@@ -2496,7 +2498,9 @@ export class JavaScriptParserVisitor {
             prefix: this.prefix(node),
             markers: emptyMarkers,
             head: this.visit(node.head),
-            spans: node.templateSpans.map(s => this.rightPadded(this.visit(s), this.suffix(s))),
+            // Use emptySpace for the last span's after - any trailing whitespace belongs to the outer context
+            spans: node.templateSpans.map((s, i, arr) =>
+                this.rightPadded(this.visit(s), i === arr.length - 1 ? emptySpace : this.suffix(s))),
             type: this.mapType(node)
         }
     }

package/src/javascript/tabs-and-indents-visitor.ts

@@ -43,7 +43,19 @@ export class TabsAndIndentsVisitor<P> extends JavaScriptVisitor<P> {
         const [parentMyIndent, parentIndentKind] = this.getParentIndentContext(cursor);
         const myIndent = this.computeMyIndent(tree, parentMyIndent, parentIndentKind);
         cursor.messages.set("myIndent", myIndent);
-        cursor.messages.set("indentKind", this.computeIndentKind(tree));
+
+        // For Binary, behavior depends on whether it's already on a continuation line
+        if (tree.kind === J.Kind.Binary) {
+            const hasNewline = tree.prefix?.whitespace?.includes("\n") ||
+                tree.prefix?.comments?.some(c => c.suffix.includes("\n"));
+            // If Binary has newline, children align. Otherwise, children get continuation.
+            cursor.messages.set("indentKind", hasNewline ? 'align' : 'continuation');
+            // For LeftPadded children (like operator), same rule applies
+            cursor.messages.set("leftPaddedContinuation", hasNewline ? 'align' : 'propagate');
+        } else {
+            cursor.messages.set("indentKind", this.computeIndentKind(tree));
+            cursor.messages.set("leftPaddedContinuation", 'propagate');
+        }
     }
 
     private getParentIndentContext(cursor: Cursor): [string, IndentKind] {
@@ -167,11 +179,29 @@ export class TabsAndIndentsVisitor<P> extends JavaScriptVisitor<P> {
         left: J.LeftPadded<T>,
         p: P
     ): Promise<J.LeftPadded<T> | undefined> {
+        const parentIndent = this.cursor.messages.get("myIndent") as string ?? "";
+        const continuation = this.cursor.messages.get("leftPaddedContinuation") as string ?? 'propagate';
+        const hasNewline = left.before.whitespace.includes("\n");
+        const shouldPropagate = hasNewline && continuation === 'propagate';
+
+        // For 'propagate' mode, update myIndent for children so nested structures get proper indent
+        const savedMyIndent = this.cursor.messages.get("myIndent");
+        if (shouldPropagate) {
+            this.cursor.messages.set("myIndent", parentIndent + this.singleIndent);
+        }
+
         const ret = await super.visitLeftPadded(left, p);
-        if (ret === undefined || !ret.before.whitespace.includes("\n")) {
+
+        // Restore myIndent
+        if (savedMyIndent !== undefined) {
+            this.cursor.messages.set("myIndent", savedMyIndent);
+        } else if (shouldPropagate) {
+            this.cursor.messages.delete("myIndent");
+        }
+
+        if (ret === undefined || !hasNewline) {
             return ret;
         }
-        const parentIndent = this.cursor.messages.get("myIndent") as string ?? "";
         return produce(ret, draft => {
             draft.before.whitespace = this.combineIndent(draft.before.whitespace, parentIndent + this.singleIndent);
         });