@openrewrite/rewrite 8.69.0-20251207-230203 → 8.69.0-20251208-174001

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

@@ -13,12 +13,25 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import {isJavaScript, JS, JSX} from "./tree";
+import {JS, JSX} from "./tree";
 import {JavaScriptVisitor} from "./visitor";
-import {isJava, J, lastWhitespace, replaceLastWhitespace} from "../java";
+import {
+    isJava,
+    isSpace,
+    J,
+    lastWhitespace,
+    normalizeSpaceIndent,
+    replaceIndentAfterLastNewline,
+    replaceLastWhitespace,
+    spaceContainsNewline,
+    stripLeadingIndent
+} from "../java";
 import {produce} from "immer";
-import {Cursor, isScope, Tree} from "../tree";
+import {Cursor, isScope, isTree, Tree} from "../tree";
+import {mapAsync} from "../util";
+import {produceAsync} from "../visitor";
 import {TabsAndIndentsStyle} from "./style";
+import {findMarker} from "../markers";
 
 type IndentKind = 'block' | 'continuation' | 'align';
 export class TabsAndIndentsVisitor<P> extends JavaScriptVisitor<P> {
@@ -48,43 +61,95 @@ export class TabsAndIndentsVisitor<P> extends JavaScriptVisitor<P> {
         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');
+            // If Binary has newline OR parent is in align mode, children align
+            const shouldAlign = hasNewline || parentIndentKind === 'align';
+            cursor.messages.set("indentKind", shouldAlign ? 'align' : 'continuation');
         } else {
             cursor.messages.set("indentKind", this.computeIndentKind(tree));
-            cursor.messages.set("leftPaddedContinuation", 'propagate');
         }
     }
 
     private getParentIndentContext(cursor: Cursor): [string, IndentKind] {
+        // Find the nearest myIndent and the nearest indentKind separately
+        // Container/RightPadded/LeftPadded inherit myIndent but don't have indentKind
+        let parentIndent: string | undefined;
+        let parentKind: IndentKind | undefined;
+
         for (let c = cursor.parent; c != null; c = c.parent) {
-            const indent = c.messages.get("myIndent") as string | undefined;
-            if (indent !== undefined) {
-                const kind = c.messages.get("indentKind") as IndentKind ?? 'continuation';
-                return [indent, kind];
+            if (parentIndent === undefined) {
+                const indent = c.messages.get("myIndent") as string | undefined;
+                if (indent !== undefined) {
+                    parentIndent = indent;
+                }
+            }
+
+            if (parentKind === undefined) {
+                const kind = c.messages.get("indentKind") as IndentKind | undefined;
+                if (kind !== undefined) {
+                    parentKind = kind;
+                }
+            }
+
+            // Found both, we can stop
+            if (parentIndent !== undefined && parentKind !== undefined) {
+                break;
             }
         }
-        return ["", 'continuation'];
+
+        return [parentIndent ?? "", parentKind ?? 'continuation'];
     }
 
     private computeMyIndent(tree: J, parentMyIndent: string, parentIndentKind: IndentKind): string {
+        // CompilationUnit is the root - it always has myIndent="" regardless of prefix content
+        if (tree.kind === JS.Kind.CompilationUnit) {
+            return "";
+        }
         if (tree.kind === J.Kind.IfElse || parentIndentKind === 'align') {
             return parentMyIndent;
         }
-        if (parentIndentKind === 'block') {
-            return parentMyIndent + this.singleIndent;
+        // Only add indent if this element starts on a new line
+        // Check both the element's prefix and any Spread marker's prefix
+        const hasNewline = this.prefixContainsNewline(tree);
+        if (!hasNewline) {
+            // Special case for JSX: children of JsxTag don't have newlines in their prefix
+            // (newlines are in text Literal nodes), but nested tags should still get block indent
+            if (this.isNestedJsxTag(tree)) {
+                return parentMyIndent + this.singleIndent;
+            }
+            return parentMyIndent;
         }
-        const hasNewline = tree.prefix?.whitespace?.includes("\n") ||
-            tree.prefix?.comments?.some(c => c.suffix.includes("\n"));
-        return hasNewline ? parentMyIndent + this.singleIndent : parentMyIndent;
+        // Add indent for block children or continuation
+        return parentMyIndent + this.singleIndent;
+    }
+
+    private prefixContainsNewline(tree: J): boolean {
+        // Check the element's own prefix
+        if (tree.prefix?.whitespace?.includes("\n") ||
+            tree.prefix?.comments?.some(c => c.suffix.includes("\n"))) {
+            return true;
+        }
+        // For elements with Spread marker, check the Spread marker's prefix
+        const spreadMarker = tree.markers?.markers?.find(m => m.kind === JS.Markers.Spread) as { prefix: J.Space } | undefined;
+        if (spreadMarker && spaceContainsNewline(spreadMarker.prefix)) {
+            return true;
+        }
+        return false;
+    }
+
+    private isNestedJsxTag(tree: J): boolean {
+        // Check if this is a JsxTag whose parent is also a JsxTag
+        if (tree.kind !== JS.Kind.JsxTag) {
+            return false;
+        }
+        const parentTree = this.cursor.parentTree();
+        return parentTree !== undefined && parentTree.value.kind === JS.Kind.JsxTag;
     }
 
     private computeIndentKind(tree: J): IndentKind {
         switch (tree.kind) {
             case J.Kind.Block:
             case J.Kind.Case:
+            case JS.Kind.JsxTag:
                 return 'block';
             case JS.Kind.CompilationUnit:
                 return 'align';
@@ -104,109 +169,345 @@ export class TabsAndIndentsVisitor<P> extends JavaScriptVisitor<P> {
         }
 
         let result = tree;
-        if (result.prefix?.whitespace?.includes("\n")) {
-            result = produce(result, draft => {
-                draft.prefix!.whitespace = this.combineIndent(draft.prefix!.whitespace, myIndent);
-            });
+
+        // Check if the element has a Spread marker - if so, normalize its prefix instead
+        const spreadMarker = result.markers?.markers?.find(m => m.kind === JS.Markers.Spread) as { prefix: J.Space } | undefined;
+        if (spreadMarker && spaceContainsNewline(spreadMarker.prefix)) {
+            const normalizedPrefix = normalizeSpaceIndent(spreadMarker.prefix, myIndent);
+            if (normalizedPrefix !== spreadMarker.prefix) {
+                result = produce(result, draft => {
+                    const spreadIdx = draft.markers.markers.findIndex(m => m.kind === JS.Markers.Spread);
+                    if (spreadIdx !== -1) {
+                        (draft.markers.markers[spreadIdx] as any).prefix = normalizedPrefix;
+                    }
+                });
+            }
+        } else if (result.prefix && spaceContainsNewline(result.prefix)) {
+            // Normalize the entire prefix space including comment suffixes
+            const normalizedPrefix = normalizeSpaceIndent(result.prefix, myIndent);
+            if (normalizedPrefix !== result.prefix) {
+                result = produce(result, draft => {
+                    draft.prefix = normalizedPrefix;
+                });
+            }
         }
 
         if (result.kind === J.Kind.Block) {
             result = this.normalizeBlockEnd(result as J.Block, myIndent);
-        } else if (result.kind === JS.Kind.JsxTag) {
-            result = this.normalizeJsxTagEnd(result as JSX.Tag, myIndent);
+        } else if (result.kind === J.Kind.Literal && this.isInsideJsxTag()) {
+            result = this.normalizeJsxTextContent(result as J.Literal, myIndent);
         }
 
         return result;
     }
 
-    private normalizeBlockEnd(block: J.Block, myIndent: string): J.Block {
-        const effectiveLastWs = lastWhitespace(block.end);
-        if (!effectiveLastWs.includes("\n")) {
-            return block;
+    private isInsideJsxTag(): boolean {
+        const parentTree = this.cursor.parentTree();
+        return parentTree !== undefined && parentTree.value.kind === JS.Kind.JsxTag;
+    }
+
+    private normalizeJsxTextContent(literal: J.Literal, myIndent: string): J.Literal {
+        if (!literal.valueSource || !literal.valueSource.includes("\n")) {
+            return literal;
         }
-        return produce(block, draft => {
-            draft.end = replaceLastWhitespace(draft.end, ws => this.combineIndent(ws, myIndent));
+
+        // Check if this literal is the last child of a JsxTag - if so, its trailing whitespace
+        // should use the parent tag's indent, not the content indent
+        const parentIndent = this.cursor.parentTree()!.messages.get("myIndent") as string | undefined;
+        const isLastChild = parentIndent !== undefined && this.isLastChildOfJsxTag(literal);
+
+        // For JSX text content, the newline is in the value, not the prefix.
+        // Since the content IS effectively on a new line, it should get block child indent.
+        // myIndent is the parent's indent (because Literal prefix has no newline),
+        // so we need to add singleIndent for content lines.
+        const contentIndent = myIndent + this.singleIndent;
+
+        // Split by newlines and normalize each line's indentation
+        const lines = literal.valueSource.split('\n');
+        const result: string[] = [];
+
+        for (let i = 0; i < lines.length; i++) {
+            if (i === 0) {
+                // Content before first newline stays as-is
+                result.push(lines[i]);
+                continue;
+            }
+
+            const content = stripLeadingIndent(lines[i]);
+
+            if (content === '') {
+                // Line has only whitespace (or is empty)
+                if (isLastChild && i === lines.length - 1) {
+                    // Trailing whitespace of last child - use parent indent for closing tag alignment
+                    result.push(parentIndent!);
+                } else if (i < lines.length - 1) {
+                    // Empty line in the middle (followed by more lines) - keep empty
+                    result.push('');
+                } else {
+                    // Trailing whitespace of non-last-child - add content indent
+                    result.push(contentIndent);
+                }
+            } else {
+                // Line has content - add proper indent
+                result.push(contentIndent + content);
+            }
+        }
+
+        const normalizedValueSource = result.join('\n');
+        if (normalizedValueSource === literal.valueSource) {
+            return literal;
+        }
+        return produce(literal, draft => {
+            draft.valueSource = normalizedValueSource;
         });
     }
 
-    private normalizeJsxTagEnd(tag: JSX.Tag, myIndent: string): JSX.Tag {
-        if (!tag.children || tag.children.length === 0) {
-            return tag;
+    private isLastChildOfJsxTag(literal: J.Literal): boolean {
+        const parentCursor = this.cursor.parentTree();
+        if (parentCursor && parentCursor.value.kind === JS.Kind.JsxTag) {
+            const tag = parentCursor.value as JSX.Tag;
+            if (tag.children && tag.children.length > 0) {
+                const lastChild = tag.children[tag.children.length - 1];
+                // Compare by id since object references might differ after transformations
+                return lastChild.kind === J.Kind.Literal && (lastChild as J.Literal).id === literal.id;
+            }
         }
-        const lastChild = tag.children[tag.children.length - 1];
-        if (lastChild.kind !== J.Kind.Literal || !lastChild.prefix.whitespace.includes("\n")) {
-            return tag;
+        return false;
+    }
+
+    private normalizeBlockEnd(block: J.Block, myIndent: string): J.Block {
+        const effectiveLastWs = lastWhitespace(block.end);
+        if (!effectiveLastWs.includes("\n")) {
+            return block;
         }
-        return produce(tag, draft => {
-            const lastChildDraft = draft.children![draft.children!.length - 1];
-            lastChildDraft.prefix.whitespace = this.combineIndent(lastChildDraft.prefix.whitespace, myIndent);
+        return produce(block, draft => {
+            draft.end = replaceLastWhitespace(draft.end, ws => replaceIndentAfterLastNewline(ws, myIndent));
         });
     }
 
     public async visitContainer<T extends J>(container: J.Container<T>, p: P): Promise<J.Container<T>> {
-        const parentIndent = this.cursor.messages.get("myIndent") as string ?? "";
-        const elementsIndent = container.before.whitespace.includes("\n")
-            ? parentIndent + this.singleIndent
-            : parentIndent;
+        // Create cursor for this container
+        this.cursor = new Cursor(container, this.cursor);
 
-        const savedMyIndent = this.cursor.messages.get("myIndent");
-        this.cursor.messages.set("myIndent", elementsIndent);
-        let ret = await super.visitContainer(container, p);
-        if (savedMyIndent !== undefined) {
-            this.cursor.messages.set("myIndent", savedMyIndent);
-        }
+        // Pre-visit hook: set up cursor messages
+        this.preVisitContainer(container);
 
-        if (ret.before.whitespace.includes("\n")) {
-            ret = produce(ret, draft => {
-                draft.before.whitespace = this.combineIndent(draft.before.whitespace, elementsIndent);
-            });
-        }
+        // Visit children (similar to base visitor but without cursor management)
+        let ret = (await produceAsync<J.Container<T>>(container, async draft => {
+            draft.before = await this.visitSpace(container.before, p);
+            (draft.elements as J.RightPadded<J>[]) = await mapAsync(container.elements, e => this.visitRightPadded(e, p));
+            draft.markers = await this.visitMarkers(container.markers, p);
+        }))!;
 
-        if (ret.elements.length > 0) {
-            const effectiveLastWs = lastWhitespace(ret.elements[ret.elements.length - 1].after);
+        // Post-visit hook: normalize indentation
+        ret = this.postVisitContainer(ret);
+
+        // Restore cursor
+        this.cursor = this.cursor.parent!;
+
+        return ret;
+    }
+
+    private preVisitContainer<T extends J>(container: J.Container<T>): void {
+        const myIndent = this.cursor.parent?.messages.get("myIndent") as string ?? "";
+        this.cursor.messages.set("myIndent", myIndent);
+        this.cursor.messages.set("indentKind", 'continuation');
+    }
+
+    private postVisitContainer<T extends J>(container: J.Container<T>): J.Container<T> {
+        const parentIndent = this.cursor.parent?.messages.get("myIndent") as string ?? "";
+
+        // Normalize the last element's after whitespace (closing delimiter like `)`)
+        // The closing delimiter should align with the parent's indent level
+        if (container.elements.length > 0) {
+            const effectiveLastWs = lastWhitespace(container.elements[container.elements.length - 1].after);
             if (effectiveLastWs.includes("\n")) {
-                ret = produce(ret, draft => {
+                return produce(container, draft => {
                     const lastDraft = draft.elements[draft.elements.length - 1];
-                    lastDraft.after = replaceLastWhitespace(lastDraft.after, ws => this.combineIndent(ws, parentIndent));
+                    lastDraft.after = replaceLastWhitespace(lastDraft.after, ws => replaceIndentAfterLastNewline(ws, parentIndent));
                 });
             }
         }
 
-        return ret;
+        return container;
     }
 
     public async visitLeftPadded<T extends J | J.Space | number | string | boolean>(
         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';
+        // Create cursor for this LeftPadded
+        this.cursor = new Cursor(left, this.cursor);
+
+        // Pre-visit hook: set up cursor messages
+        this.preVisitLeftPadded(left);
+
+        // Visit children (similar to base visitor but without cursor management)
+        let ret = await produceAsync<J.LeftPadded<T>>(left, async draft => {
+            draft.before = await this.visitSpace(left.before, p);
+            if (isTree(left.element)) {
+                (draft.element as J) = await this.visitDefined(left.element, p);
+            } else if (isSpace(left.element)) {
+                (draft.element as J.Space) = await this.visitSpace(left.element, p);
+            }
+            draft.markers = await this.visitMarkers(left.markers, p);
+        });
+
+        // Post-visit hook: normalize indentation
+        ret = this.postVisitLeftPadded(ret);
+
+        // Restore cursor
+        this.cursor = this.cursor.parent!;
+
+        return ret;
+    }
+
+    private preVisitLeftPadded<T extends J | J.Space | number | string | boolean>(left: J.LeftPadded<T>): void {
+        // Get parent indent from parent cursor
+        const parentIndent = this.cursor.parent?.messages.get("myIndent") as string ?? "";
         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);
+        // Check if parent is a Binary in align mode - if so, don't add continuation indent
+        // (Binary sets indentKind='align' when it's already on a continuation line)
+        const parentValue = this.cursor.parent?.value;
+        const parentIndentKind = this.cursor.parent?.messages.get("indentKind");
+        const shouldAlign = parentValue?.kind === J.Kind.Binary && parentIndentKind === 'align';
+
+        // Compute myIndent INCLUDING continuation if applicable
+        // This ensures child elements see the correct parent indent
+        let myIndent = parentIndent;
+        if (hasNewline && !shouldAlign) {
+            myIndent = parentIndent + this.singleIndent;
         }
 
-        const ret = await super.visitLeftPadded(left, p);
+        this.cursor.messages.set("myIndent", myIndent);
+        this.cursor.messages.set("hasNewline", hasNewline);
+    }
 
-        // Restore myIndent
-        if (savedMyIndent !== undefined) {
-            this.cursor.messages.set("myIndent", savedMyIndent);
-        } else if (shouldPropagate) {
-            this.cursor.messages.delete("myIndent");
+    private postVisitLeftPadded<T extends J | J.Space | number | string | boolean>(
+        left: J.LeftPadded<T> | undefined
+    ): J.LeftPadded<T> | undefined {
+        if (left === undefined) {
+            return undefined;
         }
 
-        if (ret === undefined || !hasNewline) {
-            return ret;
+        const hasNewline = this.cursor.messages.get("hasNewline") as boolean ?? false;
+        if (!hasNewline) {
+            return left;
         }
-        return produce(ret, draft => {
-            draft.before.whitespace = this.combineIndent(draft.before.whitespace, parentIndent + this.singleIndent);
+
+        // Use the myIndent we computed in preVisitLeftPadded (which includes continuation if applicable)
+        const targetIndent = this.cursor.messages.get("myIndent") as string ?? "";
+        return produce(left, draft => {
+            draft.before.whitespace = replaceIndentAfterLastNewline(draft.before.whitespace, targetIndent);
         });
     }
 
+    public async visitRightPadded<T extends J | boolean>(
+        right: J.RightPadded<T>,
+        p: P
+    ): Promise<J.RightPadded<T> | undefined> {
+        // Create cursor for this RightPadded
+        this.cursor = new Cursor(right, this.cursor);
+
+        // Pre-visit hook: set up cursor messages, propagate continuation if after has newline
+        this.preVisitRightPadded(right);
+
+        // Visit children (similar to base visitor but without cursor management)
+        let ret = await produceAsync<J.RightPadded<T>>(right, async draft => {
+            if (isTree(right.element)) {
+                (draft.element as J) = await this.visitDefined(right.element, p);
+            }
+            draft.after = await this.visitSpace(right.after, p);
+            draft.markers = await this.visitMarkers(right.markers, p);
+        });
+
+        // Restore cursor
+        this.cursor = this.cursor.parent!;
+
+        if (ret?.element === undefined) {
+            return undefined;
+        }
+        return ret;
+    }
+
+    private preVisitRightPadded<T extends J | boolean>(right: J.RightPadded<T>): void {
+        // Get parent indent from parent cursor
+        const parentIndent = this.cursor.parent?.messages.get("myIndent") as string ?? "";
+        const parentIndentKind = this.cursor.parent?.messages.get("indentKind") as string ?? "";
+
+        // Check if the `after` has a newline (e.g., in method chains like `db\n    .from()`)
+        const hasNewline = right.after.whitespace.includes("\n");
+
+        // Only apply chainedIndent logic for method chains (when parent is a MethodInvocation)
+        const parentKind = this.cursor.parent?.value?.kind;
+        const isMethodChain = parentKind === J.Kind.MethodInvocation;
+
+        let myIndent = parentIndent;
+        if (hasNewline && isMethodChain) {
+            // Search up the cursor hierarchy for an existing chainedIndent (to avoid stacking in method chains)
+            const existingChainedIndent = this.cursor.parent?.messages.get("chainedIndent") as string | undefined;
+            if (existingChainedIndent === undefined) {
+                myIndent = parentIndent + this.singleIndent;
+                // Set myIndent on parent so Container siblings and further chain elements use it
+                this.cursor.parent?.messages.set("myIndent", myIndent);
+                this.cursor.parent?.messages.delete("chainedIndent");
+            } else {
+                myIndent = existingChainedIndent;
+            }
+        } else if (parentIndentKind !== 'align' && isJava(right.element) && this.elementPrefixContainsNewline(right.element as J)) {
+            myIndent = parentIndent + this.singleIndent;
+            // For spread elements with newlines, mark continuation as established
+            // This allows subsequent elements on the SAME line to inherit the continuation level
+            const element = right.element as J;
+            if (this.isSpreadElement(element)) {
+                this.cursor.parent?.messages.set("continuationIndent", myIndent);
+            }
+        } else if (isJava(right.element) && !this.elementPrefixContainsNewline(right.element as J)) {
+            // Element has no newline - check if a previous sibling established continuation
+            const continuationIndent = this.cursor.parent?.messages.get("continuationIndent") as string | undefined;
+            if (continuationIndent !== undefined) {
+                myIndent = continuationIndent;
+            }
+        }
+
+        this.cursor.messages.set("myIndent", myIndent);
+        this.cursor.messages.set("indentKind", "align");
+    }
+
+    private elementPrefixContainsNewline(element: J): boolean {
+        // Check the element's own prefix
+        if (lastWhitespace(element.prefix).includes("\n")) {
+            return true;
+        }
+        // Also check for Spread marker's prefix
+        const spreadMarker = element.markers?.markers?.find(m => m.kind === JS.Markers.Spread) as { prefix: J.Space } | undefined;
+        if (spreadMarker && spaceContainsNewline(spreadMarker.prefix)) {
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Check if an element is a spread - either directly marked with Spread marker,
+     * or a PropertyAssignment whose name has a Spread marker (for object spreads).
+     */
+    private isSpreadElement(element: J): boolean {
+        // Direct spread marker on element
+        if (findMarker(element, JS.Markers.Spread)) {
+            return true;
+        }
+        // PropertyAssignment wrapping a spread (for object spread like `...obj`)
+        if (element.kind === JS.Kind.PropertyAssignment) {
+            const propAssign = element as JS.PropertyAssignment;
+            const nameElement = propAssign.name?.element;
+            if (findMarker(nameElement, JS.Markers.Spread)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
     async visit<R extends J>(tree: Tree, p: P, parent?: Cursor): Promise<R | undefined> {
         if (this.cursor?.getNearestMessage("stop") != null) {
             return tree as R;
@@ -267,14 +568,9 @@ export class TabsAndIndentsVisitor<P> extends JavaScriptVisitor<P> {
     }
 
     private isActualJNode(v: any): v is J {
-        return (isJava(v) || isJavaScript(v)) &&
+        return isJava(v) &&
             v.kind !== J.Kind.Container &&
             v.kind !== J.Kind.LeftPadded &&
             v.kind !== J.Kind.RightPadded;
     }
-
-    private combineIndent(oldWs: string, newIndent: string): string {
-        const lastNewline = oldWs.lastIndexOf("\n");
-        return oldWs.substring(0, lastNewline + 1) + newIndent;
-    }
 }

package/src/run.ts

@@ -78,13 +78,14 @@ export type ProgressCallback = (phase: 'parsing' | 'scanning' | 'processing', cu
  * Streaming version of scheduleRun that yields results as soon as each file is processed.
  * This allows callers to print diffs immediately and free memory earlier.
  *
- * Accepts either an array or an async iterable of source files. When the recipe is not
- * a scanning recipe, files are processed immediately as they're yielded from the iterable,
- * avoiding the need to collect all files into memory first.
+ * Accepts either an array or an async iterable of source files. Files are processed
+ * immediately as they're yielded from the iterable, avoiding the need to collect all
+ * files into memory before starting work.
  *
- * For scanning recipes, the scan phase completes on all files before yielding any results.
+ * For scanning recipes, each file is scanned immediately as it's pulled from the generator,
+ * then stored for the edit phase. The scan phase completes before any results are yielded.
  *
- * @param onProgress Optional callback for progress updates during parsing, scanning, and processing phases.
+ * @param onProgress Optional callback for progress updates during scanning and processing phases.
  */
 export async function* scheduleRunStreaming(
     recipe: Recipe,
@@ -96,23 +97,20 @@ export async function* scheduleRunStreaming(
     const isScanning = await hasScanningRecipe(recipe);
 
     if (isScanning) {
-        // For scanning recipes, we need to collect all files first for the scan phase
-        const files: SourceFile[] = Array.isArray(before) ? [...before] : [];
-        if (!Array.isArray(before)) {
-            let parseCount = 0;
-            for await (const sf of before) {
-                files.push(sf);
-                parseCount++;
-                onProgress?.('parsing', parseCount, -1, sf.sourcePath); // -1 = unknown total
-            }
-        }
+        // For scanning recipes, pull files from the generator and scan them immediately.
+        // Files are stored for the later edit phase.
+        const files: SourceFile[] = [];
+        const iterable = Array.isArray(before) ? before : before;
+        const knownTotal = Array.isArray(before) ? before.length : -1; // -1 = unknown total
 
-        const totalFiles = files.length;
+        // Phase 1: Pull files from generator and scan each immediately
+        let scanCount = 0;
+        for await (const b of iterable) {
+            files.push(b);
+            scanCount++;
+            onProgress?.('scanning', scanCount, knownTotal, b.sourcePath);
 
-        // Phase 1: Run scanners on all files
-        for (let i = 0; i < files.length; i++) {
-            const b = files[i];
-            onProgress?.('scanning', i + 1, totalFiles, b.sourcePath);
+            // Scan this file immediately
             await recurseRecipeList(recipe, b, async (recipe, b2) => {
                 if (recipe instanceof ScanningRecipe) {
                     return (await recipe.scanner(recipe.accumulator(cursor, ctx))).visit(b2, ctx, cursor)
@@ -120,6 +118,8 @@ export async function* scheduleRunStreaming(
             });
         }
 
+        const totalFiles = files.length;
+
         // Phase 2: Collect generated files
         const generated = (await recurseRecipeList(recipe, [] as SourceFile[], async (recipe, generated) => {
             if (recipe instanceof ScanningRecipe) {

package/src/test/rewrite-test.ts

@@ -279,9 +279,9 @@ export function dedent(s: string): string {
     const str = start > 0 || end < s.length ? s.slice(start, end) : s;
     const lines = str.split('\n');
 
-    // If we removed a leading newline, consider all lines for minIndent
-    // Otherwise, skip the first line (it's on the same line as the opening quote)
-    const startLine = start > 0 ? 0 : 1;
+    // Always consider all lines for minIndent calculation
+    // If first line has content at column 0, minIndent will be 0 and no dedenting happens
+    const startLine = 0;
 
     // Find minimum indentation
     let minIndent = Infinity;
@@ -305,9 +305,9 @@ export function dedent(s: string): string {
         return lines.join('\n');
     }
 
-    // Remove common indentation from lines (skip first line only if we didn't remove leading newline)
-    return lines.map((line, i) =>
-        (i === 0 && startLine === 1) ? line : (line.length >= minIndent ? line.slice(minIndent) : '')
+    // Remove common indentation from all lines
+    return lines.map(line =>
+        line.length >= minIndent ? line.slice(minIndent) : ''
     ).join('\n');
 }