@openrewrite/rewrite 8.96.3 → 8.96.5

package/package.json

@@ -1,108 +1,106 @@
 {
-  "name": "@openrewrite/rewrite",
-  "version": "8.96.3",
-  "license": "Moderne Source Available License",
-  "description": "OpenRewrite JavaScript.",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/openrewrite/rewrite",
-    "directory": "rewrite-javascript/rewrite"
+  "name" : "@openrewrite/rewrite",
+  "version" : "8.96.5",
+  "license" : "Moderne Source Available License",
+  "description" : "OpenRewrite JavaScript.",
+  "repository" : {
+    "type" : "git",
+    "url" : "https://github.com/openrewrite/rewrite",
+    "directory" : "rewrite-javascript/rewrite"
   },
-  "homepage": "https://github.com/openrewrite/rewrite",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "files": [
-    "dist/**",
-    "src/**"
-  ],
-  "allowScripts": {
-    "bun": true,
-    "@datadog/pprof": true
+  "homepage" : "https://github.com/openrewrite/rewrite",
+  "main" : "./dist/index.js",
+  "types" : "./dist/index.d.ts",
+  "files" : [ "dist/**", "src/**" ],
+  "allowScripts" : {
+    "bun" : true,
+    "@datadog/pprof" : true
   },
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
+  "exports" : {
+    "." : {
+      "types" : "./dist/index.d.ts",
+      "default" : "./dist/index.js"
     },
-    "./text": {
-      "types": "./dist/text/index.d.ts",
-      "default": "./dist/text/index.js"
+    "./text" : {
+      "types" : "./dist/text/index.d.ts",
+      "default" : "./dist/text/index.js"
     },
-    "./json": {
-      "types": "./dist/json/index.d.ts",
-      "default": "./dist/json/index.js"
+    "./json" : {
+      "types" : "./dist/json/index.d.ts",
+      "default" : "./dist/json/index.js"
     },
-    "./java": {
-      "types": "./dist/java/index.d.ts",
-      "default": "./dist/java/index.js"
+    "./java" : {
+      "types" : "./dist/java/index.d.ts",
+      "default" : "./dist/java/index.js"
     },
-    "./javascript": {
-      "types": "./dist/javascript/index.d.ts",
-      "default": "./dist/javascript/index.js"
+    "./javascript" : {
+      "types" : "./dist/javascript/index.d.ts",
+      "default" : "./dist/javascript/index.js"
     },
-    "./rpc": {
-      "types": "./dist/rpc/index.d.ts",
-      "default": "./dist/rpc/index.js"
+    "./rpc" : {
+      "types" : "./dist/rpc/index.d.ts",
+      "default" : "./dist/rpc/index.js"
     },
-    "./test": {
-      "types": "./dist/test/index.d.ts",
-      "default": "./dist/test/index.js"
+    "./test" : {
+      "types" : "./dist/test/index.d.ts",
+      "default" : "./dist/test/index.js"
     },
-    "./test/java-rpc": {
-      "types": "./dist/test/java-rpc.d.ts",
-      "default": "./dist/test/java-rpc.js"
+    "./test/java-rpc" : {
+      "types" : "./dist/test/java-rpc.d.ts",
+      "default" : "./dist/test/java-rpc.js"
     },
-    "./yaml": {
-      "types": "./dist/yaml/index.d.ts",
-      "default": "./dist/yaml/index.js"
+    "./yaml" : {
+      "types" : "./dist/yaml/index.d.ts",
+      "default" : "./dist/yaml/index.js"
     }
   },
-  "scripts": {
-    "prebuild": "bun -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && bun -e \"require('fs').rmSync('tsconfig.build.tsbuildinfo',{force:true})\"",
-    "build": "tsc --build tsconfig.build.json",
-    "postbuild": "bun -e \"require('fs').chmodSync('dist/rpc/server.js', 0o755); require('fs').chmodSync('dist/javascript/type-report-cli.js', 0o755)\" && npm link --no-audit --no-fund --loglevel=warn",
-    "typecheck": "tsc --noEmit -p tsconfig.test.json",
-    "dev": "tsc --watch -p tsconfig.json",
-    "test": "npm run typecheck && npm run build && vitest run",
-    "testhelper": "vitest run",
-    "build:fixtures": "tsc --build fixtures/tsconfig.json",
-    "start": "npm run build && node ./dist/rpc/server.js"
+  "scripts" : {
+    "prebuild" : "bun -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && bun -e \"require('fs').rmSync('tsconfig.build.tsbuildinfo',{force:true})\"",
+    "build" : "tsc --build tsconfig.build.json",
+    "postbuild" : "bun -e \"require('fs').chmodSync('dist/rpc/server.js', 0o755); require('fs').chmodSync('dist/javascript/type-report-cli.js', 0o755)\" && npm link --no-audit --no-fund --loglevel=warn",
+    "typecheck" : "tsc --noEmit -p tsconfig.test.json",
+    "dev" : "tsc --watch -p tsconfig.json",
+    "test" : "npm run typecheck && npm run build && vitest run",
+    "testhelper" : "vitest run",
+    "build:fixtures" : "tsc --build fixtures/tsconfig.json",
+    "start" : "npm run build && node ./dist/rpc/server.js"
   },
-  "dependencies": {
-    "@akashrajpurohit/snowflake-id": "^2.0.0",
-    "@types/node": "^22.5.4",
-    "commander": "^10.0.1",
-    "diff": "^8.0.0",
-    "jsonc-parser": "^3.3.1",
-    "mutative": "^1.3.0",
-    "picomatch": "^4.0.4",
-    "semver": "^7.7.4",
-    "tmp-promise": "^3.0.3",
-    "typescript": "^6.0.3",
-    "vscode-jsonrpc": "^8.2.1",
-    "yaml": "^2.9.0"
+  "dependencies" : {
+    "@akashrajpurohit/snowflake-id" : "^2.0.0",
+    "@types/node" : "^22.5.4",
+    "commander" : "^10.0.1",
+    "diff" : "^8.0.0",
+    "jsonc-parser" : "^3.3.1",
+    "mutative" : "^1.3.0",
+    "picomatch" : "4.0.8-backpatch-00001",
+    "semver" : "^7.7.4",
+    "tmp-promise" : "^3.0.3",
+    "typescript" : "^6.0.3",
+    "vscode-jsonrpc" : "^8.2.1",
+    "yaml" : "^2.9.0"
   },
-  "devDependencies": {
-    "@types/benchmark": "^2.1.5",
-    "@types/diff": "^8.0.0",
-    "@types/picomatch": "^4.0.2",
-    "@types/semver": "^7.7.1",
-    "@types/tmp": "^0.2.6",
-    "benchmark": "^2.1.4",
-    "bun": "^1.3.5",
-    "prettier": "^3.7.4",
-    "vitest": "^4.1.8"
+  "devDependencies" : {
+    "@types/benchmark" : "^2.1.5",
+    "@types/diff" : "^8.0.0",
+    "@types/picomatch" : "^4.0.2",
+    "@types/semver" : "^7.7.1",
+    "@types/tmp" : "^0.2.6",
+    "benchmark" : "^2.1.4",
+    "bun" : "^1.3.5",
+    "prettier" : "^3.7.4",
+    "vitest" : "^4.1.8"
   },
-  "optionalDependencies": {
-    "@pyroscope/nodejs": "^0.4.0",
-    "prettier": "^3.7.4"
+  "optionalDependencies" : {
+    "@pyroscope/nodejs" : "^0.4.0",
+    "prettier" : "^3.7.4"
   },
-  "overrides": {
-    "tmp": "^0.2.7",
-    "lodash": "^4.18.1"
+  "overrides" : {
+    "tmp" : "^0.2.7",
+    "lodash" : "^4.18.1"
   },
-  "bin": {
-    "rewrite-rpc": "./dist/rpc/server.js",
-    "rewrite-javascript-types": "./dist/javascript/type-report-cli.js"
-  }
-}
+  "bin" : {
+    "rewrite-rpc" : "./dist/rpc/server.js",
+    "rewrite-javascript-types" : "./dist/javascript/type-report-cli.js"
+  },
+  "bundleDependencies" : [ "picomatch" ]
+}

package/src/execution.ts

@@ -14,11 +14,15 @@
  * limitations under the License.
  */
 import {RpcCodec, RpcCodecs, RpcReceiveQueue, RpcSendQueue} from "./rpc";
+import {registerHeavyweight} from "./heavyweight";
 
 export class ExecutionContext {
     /** Mirrors `org.openrewrite.ExecutionContext.REQUIRE_PRINT_EQUALS_INPUT`. */
     static readonly REQUIRE_PRINT_EQUALS_INPUT = "org.openrewrite.requirePrintEqualsInput";
 
+    /** Mirrors `org.openrewrite.ExecutionContext.SCANNING_MUTATION_VALIDATION`, which the test harness sets. */
+    static readonly SCANNING_MUTATION_VALIDATION = "org.openrewrite.test.scanningMutationValidation";
+
     readonly kind: string = "org.openrewrite.InMemoryExecutionContext"
 
     constructor(public readonly messages: { [key: string | symbol]: any } = {}) {
@@ -45,6 +49,8 @@ export class ExecutionContext {
     }
 }
 
+registerHeavyweight(ExecutionContext);
+
 const executionContextCodec: RpcCodec<ExecutionContext> = {
     rpcNew(): ExecutionContext {
         return new ExecutionContext();

package/src/heavyweight.ts

@@ -0,0 +1,42 @@
+/*
+ * 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 {MarkersKind} from "./markers";
+
+const heavyweightClasses: Function[] = [];
+const heavyweightKinds = new Set<string>();
+
+/**
+ * Registers a class, or the kind of a plain object such as a marker, as a type too expensive to keep in memory for a
+ * whole run, as in a ScanningRecipe's accumulator.
+ */
+export function registerHeavyweight(type: string | (abstract new (...args: any[]) => unknown)): void {
+    if (typeof type === "string") {
+        heavyweightKinds.add(type);
+    } else if (!heavyweightClasses.includes(type)) {
+        heavyweightClasses.push(type);
+    }
+}
+
+/** The registered kind or class that `value` is of, or the kind of a tree, which is always heavyweight. */
+export function heavyweightType(value: object): string | Function | undefined {
+    const kind = (value as { kind?: unknown }).kind;
+    // a tree has an id and markers, and so do the Markers that hold its markers
+    if (typeof kind === "string" && (heavyweightKinds.has(kind) ||
+        "id" in value && "markers" in value && kind !== MarkersKind.Markers)) {
+        return kind;
+    }
+    return heavyweightClasses.find(type => value instanceof type);
+}

package/src/index.ts

@@ -33,6 +33,7 @@ export * from "./util";
 export * from "./recipe";
 export * from "./run";
 export * from "./marketplace";
+export {registerHeavyweight} from "./heavyweight";
 
 // Install all recipes in this package
 export async function activate(marketplace: RecipeMarketplace): Promise<void> {

package/src/java/tree.ts

@@ -267,7 +267,7 @@ export namespace J {
         }
     }
 
-    export interface Block extends J {
+    export interface Block extends J, Statement {
         readonly kind: typeof Kind.Block;
         readonly static: RightPadded<boolean>;
         readonly statements: RightPadded<Statement>[];
@@ -426,7 +426,7 @@ export namespace J {
         }
     }
 
-    export interface Import extends J {
+    export interface Import extends J, Statement {
         readonly kind: typeof Kind.Import;
         readonly static: LeftPadded<boolean>;
         readonly qualid: FieldAccess;
@@ -442,7 +442,7 @@ export namespace J {
         readonly modifier?: Modifier;
     }
 
-    export interface DeconstructionPattern extends J, TypedTree {
+    export interface DeconstructionPattern extends J, Expression, TypedTree {
         readonly kind: typeof Kind.DeconstructionPattern;
         readonly deconstructor: Expression;
         readonly nested: Container<J>;
@@ -490,7 +490,7 @@ export namespace J {
         readonly codePoint: string;
     }
 
-    export interface MemberReference extends J, MethodCall {
+    export interface MemberReference extends J, TypedTree, MethodCall {
         readonly kind: typeof Kind.MemberReference;
         readonly containing: RightPadded<Expression>;
         readonly typeParameters?: Container<Expression>;
@@ -499,7 +499,7 @@ export namespace J {
         readonly variableType?: Type.Variable;
     }
 
-    export interface MethodDeclaration extends J, TypedTree {
+    export interface MethodDeclaration extends J, Statement, TypedTree {
         readonly kind: typeof Kind.MethodDeclaration;
         readonly leadingAnnotations: Annotation[];
         readonly modifiers: Modifier[];
@@ -515,7 +515,7 @@ export namespace J {
         readonly methodType?: Type.Method;
     }
 
-    export interface MethodInvocation extends J, TypedTree, MethodCall {
+    export interface MethodInvocation extends J, Statement, TypedTree, MethodCall {
         readonly kind: typeof Kind.MethodInvocation;
         readonly select?: RightPadded<Expression>;
         readonly typeParameters?: Container<Expression>;
@@ -567,7 +567,7 @@ export namespace J {
         readonly type?: Type;
     }
 
-    export interface NewClass extends J, TypedTree, MethodCall {
+    export interface NewClass extends J, Statement, TypedTree, MethodCall {
         readonly kind: typeof Kind.NewClass;
         readonly enclosing?: RightPadded<Expression>;
         readonly new: Space;
@@ -583,13 +583,13 @@ export namespace J {
         readonly typeTree: RightPadded<TypeTree>;
     }
 
-    export interface Package extends J {
+    export interface Package extends J, Statement {
         readonly kind: typeof Kind.Package;
         readonly expression: Expression;
         readonly annotations?: Annotation[];
     }
 
-    export interface ParameterizedType extends J, TypeTree {
+    export interface ParameterizedType extends J, TypeTree, Expression {
         readonly kind: typeof Kind.ParameterizedType;
         readonly class: NameTree;
         readonly typeParameters?: Container<Expression>;
@@ -711,7 +711,7 @@ export namespace J {
         }
     }
 
-    export interface VariableDeclarations extends J, TypedTree {
+    export interface VariableDeclarations extends J, Statement, TypedTree {
         readonly kind: typeof Kind.VariableDeclarations;
         readonly leadingAnnotations: Annotation[];
         readonly modifiers: Modifier[];
@@ -721,7 +721,7 @@ export namespace J {
     }
 
     export namespace VariableDeclarations {
-        export interface NamedVariable extends J {
+        export interface NamedVariable extends J, NameTree {
             readonly kind: typeof Kind.NamedVariable;
             readonly name: VariableDeclarator;
             readonly dimensionsAfterName: LeftPadded<Space>[];

package/src/java/visitor.ts

@@ -199,6 +199,12 @@ export class JavaVisitor<P> extends TreeVisitor<J, P> {
         }
         assignOp = expression as J.AssignmentOperation;
 
+        const statement = await this.visitStatement(assignOp, p);
+        if (!statement?.kind || statement.kind !== J.Kind.AssignmentOperation) {
+            return statement;
+        }
+        assignOp = statement as J.AssignmentOperation;
+
         const updates = {
             prefix: await this.visitSpace(assignOp.prefix, p),
             markers: await this.visitMarkers(assignOp.markers, p),
@@ -215,6 +221,12 @@ export class JavaVisitor<P> extends TreeVisitor<J, P> {
         if (!expression?.kind || expression.kind !== J.Kind.Binary) {
             return expression;
         }
+        const given = this.cursor;
+        if (expression !== binary && given.value === binary) {
+            // the operands are visited under the binary that holds them, where a template reads their slots
+            this.cursor = new Cursor(expression, given.parent);
+            given.messages.forEach((value, key) => this.cursor.messages.set(key, value));
+        }
         binary = expression as J.Binary;
 
         const updates = {
@@ -225,10 +237,21 @@ export class JavaVisitor<P> extends TreeVisitor<J, P> {
             right: await this.visitDefined(binary.right, p) as Expression,
             type: await this.visitType(binary.type, p)
         };
+        if (this.cursor !== given) {
+            // what follows reads the cursor of the binary it was given, as for every other tree
+            this.cursor.messages.forEach((value, key) => given.messages.set(key, value));
+            this.cursor = given;
+        }
         return updateIfChanged(binary, updates);
     }
 
     protected async visitBlock(block: J.Block, p: P): Promise<J | undefined> {
+        const statement = await this.visitStatement(block, p);
+        if (!statement?.kind || statement.kind !== J.Kind.Block) {
+            return statement;
+        }
+        block = statement as J.Block;
+
         const updates = {
             prefix: await this.visitSpace(block.prefix, p),
             markers: await this.visitMarkers(block.markers, p),
@@ -340,6 +363,12 @@ export class JavaVisitor<P> extends TreeVisitor<J, P> {
     }
 
     protected async visitControlParentheses<T extends J>(controlParens: J.ControlParentheses<T>, p: P): Promise<J | undefined> {
+        const expression = await this.visitExpression(controlParens, p);
+        if (!expression?.kind || expression.kind !== J.Kind.ControlParentheses) {
+            return expression;
+        }
+        controlParens = expression as J.ControlParentheses<T>;
+
         const updates: any = {
             prefix: await this.visitSpace(controlParens.prefix, p),
             markers: await this.visitMarkers(controlParens.markers, p),
@@ -797,6 +826,12 @@ export class JavaVisitor<P> extends TreeVisitor<J, P> {
         }
         newClass = expression as J.NewClass;
 
+        const statement = await this.visitStatement(newClass, p);
+        if (!statement?.kind || statement.kind !== J.Kind.NewClass) {
+            return statement;
+        }
+        newClass = statement as J.NewClass;
+
         const updates: any = {
             prefix: await this.visitSpace(newClass.prefix, p),
             markers: await this.visitMarkers(newClass.markers, p),
@@ -845,6 +880,12 @@ export class JavaVisitor<P> extends TreeVisitor<J, P> {
     }
 
     protected async visitParameterizedType(parameterizedType: J.ParameterizedType, p: P): Promise<J | undefined> {
+        const expression = await this.visitExpression(parameterizedType, p);
+        if (!expression?.kind || expression.kind !== J.Kind.ParameterizedType) {
+            return expression;
+        }
+        parameterizedType = expression as J.ParameterizedType;
+
         const updates: any = {
             prefix: await this.visitSpace(parameterizedType.prefix, p),
             markers: await this.visitMarkers(parameterizedType.markers, p),
@@ -856,6 +897,12 @@ export class JavaVisitor<P> extends TreeVisitor<J, P> {
     }
 
     protected async visitParentheses<T extends J>(parentheses: J.Parentheses<T>, p: P): Promise<J | undefined> {
+        const expression = await this.visitExpression(parentheses, p);
+        if (!expression?.kind || expression.kind !== J.Kind.Parentheses) {
+            return expression;
+        }
+        parentheses = expression as J.Parentheses<T>;
+
         const updates: any = {
             prefix: await this.visitSpace(parentheses.prefix, p),
             markers: await this.visitMarkers(parentheses.markers, p),
@@ -1205,9 +1252,12 @@ export class JavaVisitor<P> extends TreeVisitor<J, P> {
 
         const updates: any = {
             prefix: await this.visitSpace(aYield.prefix, p),
-            markers: await this.visitMarkers(aYield.markers, p),
-            value: await this.visitDefined(aYield.value, p) as Expression
+            markers: await this.visitMarkers(aYield.markers, p)
         };
+        // a bare `yield` has no value
+        if (aYield.value) {
+            updates.value = await this.visitDefined(aYield.value, p) as Expression;
+        }
         return updateIfChanged(aYield, updates);
     }
 

package/src/javascript/add-import.ts

@@ -12,6 +12,7 @@ import {bindingNames, compilationUnitOf, cursorOf, declarationsOf, deconflict, i
 import {create as produce, Draft} from "mutative";
 import {autoFormat} from "./format";
 import {getPrettierStyle} from "./format/prettier-format";
+import ts from "typescript";
 
 export type QuoteChar = "'" | '"';
 
@@ -562,7 +563,8 @@ function claimedName(v: unknown): string | undefined {
 /**
  * The parser lifts surrogate pairs out of `valueSource` into `unicodeEscapes` and, when it does,
  * sets `value` to the quoted source (`parser.ts` `mapLiteral`), so neither field alone is the
- * module name. Reuniting them and stripping the quotes yields it for either shape of literal.
+ * module name. Reuniting them and reading the quoted text as the language does yields it for
+ * either shape of literal.
  */
 export function moduleNameOf(module: string | J.Literal): string {
     if (typeof module === 'string') {
@@ -579,6 +581,13 @@ export function moduleNameOf(module: string | J.Literal): string {
         cut = escape.valueSourceIndex;
     }
     restored += source.slice(cut);
+    // an escape such as `\u00dc` names the character it spells
+    const scanner = ts.createScanner(ts.ScriptTarget.Latest, false, ts.LanguageVariant.Standard, restored);
+    const token = scanner.scan();
+    if ((token === ts.SyntaxKind.StringLiteral || token === ts.SyntaxKind.NoSubstitutionTemplateLiteral) &&
+        scanner.getTokenEnd() === restored.length) {
+        return scanner.getTokenValue();
+    }
     const quote = restored.charAt(0);
     return (quote === "'" || quote === '"' || quote === '`') && restored.endsWith(quote) && restored.length > 1
         ? restored.slice(1, -1)
@@ -1583,7 +1592,7 @@ export class AddImport<P> extends JavaScriptVisitor<P> {
             value: this.module,
             valueSource,
             unicodeEscapes: this.moduleUnicodeEscapes,
-            type: undefined
+            type: Type.Primitive.String
         };
     }
 

package/src/javascript/amd.ts

@@ -25,7 +25,8 @@ import {
     rightPadded,
     space,
     Statement,
-    TrailingComma
+    TrailingComma,
+    Type
 } from "../java";
 import {JS} from "./tree";
 import {moduleNameOf} from "./add-import";
@@ -428,7 +429,8 @@ function dependencyLiteral(module: string, quote: string): J.Literal {
         prefix: emptySpace,
         markers: emptyMarkers,
         value: module,
-        valueSource: `${quote}${module}${quote}`
+        valueSource: `${quote}${module}${quote}`,
+        type: Type.Primitive.String
     };
 }
 

package/src/javascript/cleanup/add-parse-int-radix.ts

@@ -18,7 +18,7 @@ import {Recipe} from "../../recipe";
 import {TreeVisitor} from "../../visitor";
 import {ExecutionContext} from "../../execution";
 import {JavaScriptVisitor} from "../visitor";
-import {J, singleSpace} from "../../java";
+import {J, singleSpace, Type} from "../../java";
 import {emptyMarkers} from "../../markers";
 import {randomId} from "../../uuid";
 
@@ -73,7 +73,7 @@ export class AddParseIntRadix extends Recipe {
                     value: 10,
                     valueSource: '10',
                     unicodeEscapes: undefined,
-                    type: undefined
+                    type: Type.Primitive.Double
                 };
 
                 return {

package/src/javascript/format/format.ts

@@ -26,6 +26,7 @@ import {TabsAndIndentsVisitor} from "./tabs-and-indents-visitor";
 import {NormalizeWhitespaceVisitor} from "./normalize-whitespace-visitor";
 import {MinimumViableSpacingVisitor} from "./minimum-viable-spacing-visitor";
 import {applyPrettierFormatting, getPrettierStyle} from "./prettier-format";
+import {AsyncLocalStorage} from "node:async_hooks";
 
 export {TabsAndIndentsVisitor} from "./tabs-and-indents-visitor";
 export {NormalizeWhitespaceVisitor} from "./normalize-whitespace-visitor";
@@ -56,6 +57,22 @@ export const autoIndent = async <J2 extends J, P>(j: J2, p: P, parent?: Cursor):
     return await new TabsAndIndentsVisitor(style).visit(j, p, parent) as J2;
 }
 
+/**
+ * Hears about each request to auto-format a tree made while it listens, so that a test harness can check that a
+ * recipe formats only what it changed.
+ */
+export interface FormattingListener {
+    /** AutoformatVisitor calls this before it formats `tree`, stopping after `stopAfter` when it is given. */
+    onFormat(tree: Tree, stopAfter: Tree | undefined, cursor: Cursor | undefined): void;
+}
+
+const formattingListener = new AsyncLocalStorage<FormattingListener>();
+
+/** Runs `run`, telling `listener` about the formatting it requests. */
+export function listenToFormatting<T>(listener: FormattingListener, run: () => Promise<T>): Promise<T> {
+    return formattingListener.run(listener, run);
+}
+
 /**
  * Formats JavaScript/TypeScript code using a comprehensive set of formatting rules.
  *
@@ -77,6 +94,7 @@ export class AutoformatVisitor<P> extends JavaScriptVisitor<P> {
     }
 
     async visit<R extends J>(tree: Tree, p: P, cursor?: Cursor): Promise<R | undefined> {
+        formattingListener.getStore()?.onFormat(tree, this.stopAfter, cursor);
         const prettierStyle = getPrettierStyle(tree, cursor, this.styles);
         if (prettierStyle) {
             const formatted = await applyPrettierFormatting(tree as R, prettierStyle, p, cursor, this.stopAfter);
@@ -1121,7 +1139,7 @@ export class BlankLinesVisitor<P> extends JavaScriptVisitor<P> {
             } else if (parent?.kind === J.Kind.Block && grandparent?.kind !== J.Kind.NewClass && grandparent?.kind !== JS.Kind.TypeLiteral ||
                       (parent?.kind === JS.Kind.CompilationUnit && (parent! as JS.CompilationUnit).statements[0].element.id != draft.id) ||
                       (parent?.kind === J.Kind.Case && this.isInsideCaseStatements(parent as J.Case, draft))) {
-                if (draft.kind != J.Kind.Case) {
+                if (draft.kind != J.Kind.Case && !this.opensCaseBody(parent, draft)) {
                     this.ensurePrefixHasNewLine(draft);
                 }
             }
@@ -1151,6 +1169,12 @@ export class BlankLinesVisitor<P> extends JavaScriptVisitor<P> {
      * Check if a statement is inside a Case's statements container or body,
      * not inside the caseLabels container.
      */
+    /** A block that opens a case's statements stays on the line of its label, as in `case X: {`. */
+    private opensCaseBody(parent: J | undefined, statement: J): boolean {
+        return parent?.kind === J.Kind.Case && statement.kind === J.Kind.Block &&
+            (parent as J.Case).statements.elements[0]?.element.id === statement.id;
+    }
+
     private isInsideCaseStatements(caseNode: J.Case, statement: J): boolean {
         // Check if statement is in the statements container
         if (caseNode.statements.elements.some(s => s.element.id === statement.id)) {

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

@@ -408,6 +408,10 @@ export class TabsAndIndentsVisitor<P> extends JavaScriptVisitor<P> {
             return literal;
         }
         return produce(literal, draft => {
+            // JSX text is its own value, as the parser makes it
+            if (draft.value === draft.valueSource) {
+                draft.value = normalizedValueSource;
+            }
             draft.valueSource = normalizedValueSource;
         });
     }

package/src/javascript/format/whitespace-reconciler.ts

@@ -416,6 +416,10 @@ export class WhitespaceReconciler {
         original: J.Identifier | J.Literal,
         formatted: J.Identifier | J.Literal
     ): J.Identifier | J.Literal {
+        // A literal's type follows from how it is written, so an identifier's is not the literal's
+        if (isLiteral(formatted)) {
+            return formatted;
+        }
         const result: Record<string, unknown> = { ...formatted };
 
         // Preserve type attribution - both Identifier and Literal have `type`