miniread 1.5.0 → 1.7.0

package/dist/transforms/rename-event-parameters/rename-event-parameters-transform.js

@@ -1,4 +1,6 @@
 import { createRequire } from "node:module";
+import { RenameGroup } from "../../core/stable-naming.js";
+import { getFilesToProcess, } from "../../core/types.js";
 import { processEventHandlerFunction } from "./process-event-handler-function.js";
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
@@ -9,28 +11,29 @@ export const renameEventParametersTransform = {
     scope: "file",
     parallelizable: true,
     transform(context) {
-        const { projectGraph } = context;
         let nodesVisited = 0;
-        const stats = { transformationsApplied: 0 };
-        for (const [, fileInfo] of projectGraph.files) {
+        let transformationsApplied = 0;
+        for (const fileInfo of getFilesToProcess(context)) {
+            const group = new RenameGroup();
             traverse(fileInfo.ast, {
                 FunctionDeclaration(path) {
                     nodesVisited++;
-                    processEventHandlerFunction(path, stats);
+                    processEventHandlerFunction(path, group);
                 },
                 FunctionExpression(path) {
                     nodesVisited++;
-                    processEventHandlerFunction(path, stats);
+                    processEventHandlerFunction(path, group);
                 },
                 ArrowFunctionExpression(path) {
                     nodesVisited++;
-                    processEventHandlerFunction(path, stats);
+                    processEventHandlerFunction(path, group);
                 },
             });
+            transformationsApplied += group.apply();
         }
         return Promise.resolve({
             nodesVisited,
-            transformationsApplied: stats.transformationsApplied,
+            transformationsApplied,
         });
     },
 };

package/dist/transforms/rename-loop-index-variables/rename-loop-index-variables-transform.js

@@ -1,4 +1,5 @@
 import { createRequire } from "node:module";
+import { isStableRenamed, RenameGroup } from "../../core/stable-naming.js";
 import { getFilesToProcess, } from "../../core/types.js";
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
@@ -15,10 +16,11 @@ const getRenamedAncestorLoopCount = (path, renamedLoops) => {
     }
     return count;
 };
-const getTargetIndexName = (renamedAncestorLoopCount) => {
+const BASE_NAME = "index";
+const getTargetIndexBaseName = (renamedAncestorLoopCount) => {
     if (renamedAncestorLoopCount === 0)
-        return "index";
-    return `index${renamedAncestorLoopCount + 1}`;
+        return BASE_NAME;
+    return `${BASE_NAME}${renamedAncestorLoopCount + 1}`;
 };
 const getLoopCounterNameIfEligible = (path) => {
     const init = path.node.init;
@@ -91,31 +93,35 @@ const getLoopCounterNameIfEligible = (path) => {
 };
 export const renameLoopIndexVariablesTransform = {
     id: "rename-loop-index-variables",
-    description: "Renames numeric for-loop counters to index/index2/... based on nesting depth",
+    description: "Renames numeric for-loop counters to $index/$index2/... based on nesting depth",
     scope: "file",
     parallelizable: true,
     transform(context) {
         let nodesVisited = 0;
         let transformationsApplied = 0;
         for (const fileInfo of getFilesToProcess(context)) {
-            const renamedLoops = new WeakMap();
+            const group = new RenameGroup();
+            const eligibleLoops = new WeakMap();
             traverse(fileInfo.ast, {
                 ForStatement(path) {
                     nodesVisited++;
                     const loopCounterName = getLoopCounterNameIfEligible(path);
                     if (!loopCounterName)
                         return;
-                    const renamedAncestorLoopCount = getRenamedAncestorLoopCount(path, renamedLoops);
-                    const targetName = getTargetIndexName(renamedAncestorLoopCount);
-                    if (loopCounterName === targetName)
+                    // Skip already-stable names
+                    if (isStableRenamed(loopCounterName))
                         return;
-                    if (path.scope.hasBinding(targetName))
-                        return;
-                    path.scope.rename(loopCounterName, targetName);
-                    renamedLoops.set(path.node, targetName);
-                    transformationsApplied++;
+                    const renamedAncestorLoopCount = getRenamedAncestorLoopCount(path, eligibleLoops);
+                    const baseName = getTargetIndexBaseName(renamedAncestorLoopCount);
+                    eligibleLoops.set(path.node, baseName);
+                    group.add({
+                        scope: path.scope,
+                        currentName: loopCounterName,
+                        baseName,
+                    });
                 },
             });
+            transformationsApplied += group.apply();
         }
         return Promise.resolve({
             nodesVisited,

package/dist/transforms/rename-promise-executor-parameters/rename-promise-executor-parameters-transform.js

@@ -1,13 +1,15 @@
 import { createRequire } from "node:module";
+import { isStableRenamed } from "../../core/stable-naming.js";
 import { getFilesToProcess, } from "../../core/types.js";
 import { getExecutorFunctionIfEligible, isAssignedToOnHandlerProperty, isDirectCallOfBinding, wouldShadowReferencedOuterBinding, } from "./promise-executor-heuristics.js";
 import { canRenameBindingSafely, renameBindingIfSafe, } from "./rename-binding-if-safe.js";
+const STABLE_PREFIX = "$";
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 const traverse = require("@babel/traverse").default;
 export const renamePromiseExecutorParametersTransform = {
     id: "rename-promise-executor-parameters",
-    description: "Renames promise-like executor parameters in `new X(executor)` to resolve/reject when usage is high-confidence",
+    description: "Renames promise-like executor parameters in `new X(executor)` to $resolve/$reject when usage is high-confidence",
     scope: "file",
     parallelizable: true,
     transform(context) {
@@ -22,6 +24,11 @@ export const renamePromiseExecutorParametersTransform = {
                         return;
                     const [resolveParameter, rejectParameter] = executorPath.node
                         .params;
+                    // Skip already-stable names
+                    if (isStableRenamed(resolveParameter.name))
+                        return;
+                    if (isStableRenamed(rejectParameter.name))
+                        return;
                     const bindingScope = executorPath.scope;
                     const resolveBinding = bindingScope.getBinding(resolveParameter.name);
                     const rejectBinding = bindingScope.getBinding(rejectParameter.name);
@@ -41,10 +48,10 @@ export const renamePromiseExecutorParametersTransform = {
                         isAssignedToOnHandlerProperty(referencePath));
                     if (!rejectIsOnlyCalledOrHandlerAssigned)
                         return;
-                    const resolveWouldShadow = wouldShadowReferencedOuterBinding(executorPath, "resolve");
-                    const rejectWouldShadow = wouldShadowReferencedOuterBinding(executorPath, "reject");
-                    const targetResolveName = "resolve";
-                    const targetRejectName = "reject";
+                    const targetResolveName = `${STABLE_PREFIX}resolve`;
+                    const targetRejectName = `${STABLE_PREFIX}reject`;
+                    const resolveWouldShadow = wouldShadowReferencedOuterBinding(executorPath, targetResolveName);
+                    const rejectWouldShadow = wouldShadowReferencedOuterBinding(executorPath, targetRejectName);
                     const wantsResolveRename = resolveParameter.name !== targetResolveName;
                     const wantsRejectRename = rejectParameter.name !== targetRejectName;
                     const canRenameResolve = !wantsResolveRename ||

package/dist/transforms/rename-timeout-ids/rename-timeout-ids-transform.d.ts

@@ -1,2 +1,2 @@
-import type { Transform } from "../../core/types.js";
+import { type Transform } from "../../core/types.js";
 export declare const renameTimeoutIdsTransform: Transform;

package/dist/transforms/rename-timeout-ids/rename-timeout-ids-transform.js

@@ -1,6 +1,6 @@
 import { createRequire } from "node:module";
-import { getFilesToProcess } from "../../core/types.js";
-import { getTargetName } from "../rename-binding/get-target-name.js";
+import { isStableRenamed, RenameGroup } from "../../core/stable-naming.js";
+import { getFilesToProcess, } from "../../core/types.js";
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 const traverse = require("@babel/traverse").default;
@@ -40,20 +40,22 @@ const isClearTimeoutCallArgument = (referencePath, bindingName) => {
 };
 export const renameTimeoutIdsTransform = {
     id: "rename-timeout-ids",
-    description: "Renames setTimeout handle variables to timeoutId/timeoutId2/... when usage is only clearTimeout(...)",
+    description: "Renames setTimeout handle variables to $timeoutId/$timeoutId2/... or timeoutId/timeoutId2/... when usage is only clearTimeout(...)",
     scope: "file",
     parallelizable: true,
     transform(context) {
         let nodesVisited = 0;
         let transformationsApplied = 0;
         for (const fileInfo of getFilesToProcess(context)) {
+            const group = new RenameGroup();
             traverse(fileInfo.ast, {
                 VariableDeclarator(path) {
                     nodesVisited++;
                     const id = path.node.id;
                     if (id.type !== "Identifier")
                         return;
-                    if (id.name.length > 2)
+                    // Skip already-stable names
+                    if (isStableRenamed(id.name))
                         return;
                     const init = path.node.init;
                     if (init?.type !== "CallExpression")
@@ -69,17 +71,14 @@ export const renameTimeoutIdsTransform = {
                         return;
                     if (!binding.referencePaths.every((referencePath) => isClearTimeoutCallArgument(referencePath, id.name)))
                         return;
-                    const targetName = getTargetName(path.scope, binding, {
+                    group.add({
+                        scope: path.scope,
+                        currentName: id.name,
                         baseName: BASE_NAME,
                     });
-                    if (!targetName)
-                        return;
-                    if (id.name === targetName)
-                        return;
-                    path.scope.rename(id.name, targetName);
-                    transformationsApplied++;
                 },
             });
+            transformationsApplied += group.apply();
         }
         return Promise.resolve({ nodesVisited, transformationsApplied });
     },

package/dist/transforms/rename-use-reference-guards/rename-use-reference-guards-transform.js

@@ -1,28 +1,28 @@
 import { createRequire } from "node:module";
+import { RenameGroup } from "../../core/stable-naming.js";
 import { getFilesToProcess, } from "../../core/types.js";
 import { getReferenceUsage } from "./get-reference-usage.js";
-import { getTargetName } from "./get-target-name.js";
 import { isUseReferenceFalseInitializer } from "./is-use-reference-false-initializer.js";
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 const traverse = require("@babel/traverse").default;
+const BASE_NAME = "hasRunRef";
 const renameUseReferenceGuardsTransform = {
     id: "rename-use-reference-guards",
-    description: "Renames boolean useRef(false) guard variables to hasRunRef/hasRunRef2/...",
+    description: "Renames boolean useRef(false) guard variables to $hasRunRef/$hasRunRef2/... or hasRunRef/hasRunRef2/...",
     scope: "file",
     parallelizable: true,
     transform(context) {
         let nodesVisited = 0;
         let transformationsApplied = 0;
         for (const fileInfo of getFilesToProcess(context)) {
+            const group = new RenameGroup();
             traverse(fileInfo.ast, {
                 VariableDeclarator(path) {
                     nodesVisited++;
                     const id = path.node.id;
                     if (id.type !== "Identifier")
                         return;
-                    if (id.name.length > 2)
-                        return;
                     if (!isUseReferenceFalseInitializer(path.node))
                         return;
                     const binding = path.scope.getBinding(id.name);
@@ -36,15 +36,14 @@ const renameUseReferenceGuardsTransform = {
                         !usage.hasTrueWrite ||
                         usage.hasFalseWrite)
                         return;
-                    const targetName = getTargetName(path.scope, binding);
-                    if (!targetName)
-                        return;
-                    if (id.name === targetName)
-                        return;
-                    path.scope.rename(id.name, targetName);
-                    transformationsApplied++;
+                    group.add({
+                        scope: path.scope,
+                        currentName: id.name,
+                        baseName: BASE_NAME,
+                    });
                 },
             });
+            transformationsApplied += group.apply();
         }
         return Promise.resolve({
             nodesVisited,

package/dist/transforms/rename-use-reference-guards-v2/get-member-expression-for-reference.d.ts

@@ -0,0 +1,3 @@
+import type { NodePath } from "@babel/traverse";
+import type { Identifier, MemberExpression, OptionalMemberExpression } from "@babel/types";
+export declare const getMemberExpressionForReference: (referencePath: NodePath<Identifier>) => NodePath<MemberExpression | OptionalMemberExpression> | undefined;

package/dist/transforms/rename-use-reference-guards-v2/get-member-expression-for-reference.js

@@ -0,0 +1,10 @@
+export const getMemberExpressionForReference = (referencePath) => {
+    const parentPath = referencePath.parentPath;
+    if (parentPath.isMemberExpression() &&
+        parentPath.node.object === referencePath.node)
+        return parentPath;
+    if (parentPath.isOptionalMemberExpression() &&
+        parentPath.node.object === referencePath.node)
+        return parentPath;
+    return;
+};

package/dist/transforms/rename-use-reference-guards-v2/get-reference-usage.d.ts

@@ -0,0 +1,8 @@
+import type { Binding } from "@babel/traverse";
+type ReferenceUsage = {
+    isSafe: boolean;
+    hasRead: boolean;
+    hasTrueWrite: boolean;
+};
+export declare const getReferenceUsage: (binding: Binding) => ReferenceUsage;
+export {};

package/dist/transforms/rename-use-reference-guards-v2/get-reference-usage.js

@@ -0,0 +1,58 @@
+import { getMemberExpressionForReference } from "./get-member-expression-for-reference.js";
+const getKnownBooleanValue = (expression) => {
+    if (expression.type === "BooleanLiteral")
+        return expression.value;
+    if (expression.type === "UnaryExpression" &&
+        expression.operator === "!" &&
+        expression.argument.type === "NumericLiteral" &&
+        (expression.argument.value === 0 || expression.argument.value === 1)) {
+        return !expression.argument.value;
+    }
+    return;
+};
+export const getReferenceUsage = (binding) => {
+    let hasRead = false;
+    let hasTrueWrite = false;
+    for (const referencePath of binding.referencePaths) {
+        if (!referencePath.isIdentifier())
+            return { isSafe: false, hasRead, hasTrueWrite };
+        const memberPath = getMemberExpressionForReference(referencePath);
+        if (!memberPath)
+            return { isSafe: false, hasRead, hasTrueWrite };
+        const memberNode = memberPath.node;
+        if (memberNode.computed)
+            return { isSafe: false, hasRead, hasTrueWrite };
+        if (memberNode.property.type !== "Identifier" ||
+            memberNode.property.name !== "current") {
+            return { isSafe: false, hasRead, hasTrueWrite };
+        }
+        const parentPath = memberPath.parentPath;
+        if (parentPath.isAssignmentExpression() &&
+            parentPath.node.left === memberNode) {
+            if (parentPath.node.operator !== "=")
+                return { isSafe: false, hasRead, hasTrueWrite };
+            const right = parentPath.node.right;
+            const value = getKnownBooleanValue(right);
+            if (value === undefined)
+                return { isSafe: false, hasRead, hasTrueWrite };
+            if (value) {
+                hasTrueWrite = true;
+            }
+            continue;
+        }
+        if (parentPath.isUpdateExpression() &&
+            parentPath.node.argument === memberNode) {
+            return { isSafe: false, hasRead, hasTrueWrite };
+        }
+        if (parentPath.isUnaryExpression() &&
+            parentPath.node.operator === "delete" &&
+            parentPath.node.argument === memberNode) {
+            return { isSafe: false, hasRead, hasTrueWrite };
+        }
+        if (!memberPath.isReferenced()) {
+            return { isSafe: false, hasRead, hasTrueWrite };
+        }
+        hasRead = true;
+    }
+    return { isSafe: true, hasRead, hasTrueWrite };
+};

package/dist/transforms/rename-use-reference-guards-v2/is-use-reference-false-initializer.d.ts

@@ -0,0 +1,2 @@
+import type { VariableDeclarator } from "@babel/types";
+export declare const isUseReferenceFalseInitializer: (declarator: VariableDeclarator) => boolean;

package/dist/transforms/rename-use-reference-guards-v2/is-use-reference-false-initializer.js

@@ -0,0 +1,40 @@
+const isKnownFalseValue = (expression) => {
+    if (expression.type === "BooleanLiteral")
+        return !expression.value;
+    if (expression.type === "UnaryExpression" &&
+        expression.operator === "!" &&
+        expression.argument.type === "NumericLiteral" &&
+        expression.argument.value === 1) {
+        return true;
+    }
+    return false;
+};
+export const isUseReferenceFalseInitializer = (declarator) => {
+    const init = declarator.init;
+    if (!init)
+        return false;
+    if (init.type !== "CallExpression")
+        return false;
+    if (init.arguments.length !== 1)
+        return false;
+    const argument = init.arguments[0];
+    if (!argument)
+        return false;
+    if (argument.type === "SpreadElement")
+        return false;
+    if (argument.type === "ArgumentPlaceholder")
+        return false;
+    if (!isKnownFalseValue(argument))
+        return false;
+    const callee = init.callee;
+    if (callee.type === "Identifier") {
+        return callee.name === "useRef";
+    }
+    if (callee.type !== "MemberExpression")
+        return false;
+    if (callee.computed)
+        return false;
+    if (callee.property.type !== "Identifier")
+        return false;
+    return callee.property.name === "useRef";
+};

package/dist/transforms/rename-use-reference-guards-v2/rename-use-reference-guards-v2-transform.d.ts

@@ -0,0 +1,3 @@
+import { type Transform } from "../../core/types.js";
+declare const renameUseReferenceGuardsV2Transform: Transform;
+export { renameUseReferenceGuardsV2Transform };

package/dist/transforms/rename-use-reference-guards-v2/rename-use-reference-guards-v2-transform.js

@@ -0,0 +1,54 @@
+import { createRequire } from "node:module";
+import { isStableRenamed, RenameGroup } from "../../core/stable-naming.js";
+import { getFilesToProcess, } from "../../core/types.js";
+import { getReferenceUsage } from "./get-reference-usage.js";
+import { isUseReferenceFalseInitializer } from "./is-use-reference-false-initializer.js";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const traverse = require("@babel/traverse").default;
+const BASE_NAME = "hasRunRef";
+const renameUseReferenceGuardsV2Transform = {
+    id: "rename-use-reference-guards-v2",
+    description: "Renames boolean useRef(false) guard variables (including reset-to-false guards) to $hasRunRef/$hasRunRef2/... or hasRunRef/hasRunRef2/...",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const fileInfo of getFilesToProcess(context)) {
+            const group = new RenameGroup();
+            traverse(fileInfo.ast, {
+                VariableDeclarator(path) {
+                    nodesVisited++;
+                    const id = path.node.id;
+                    if (id.type !== "Identifier")
+                        return;
+                    if (isStableRenamed(id.name))
+                        return;
+                    if (!isUseReferenceFalseInitializer(path.node))
+                        return;
+                    const binding = path.scope.getBinding(id.name);
+                    if (!binding)
+                        return;
+                    if (!binding.constant)
+                        return;
+                    const usage = getReferenceUsage(binding);
+                    // Unlike v1, this version also accepts guards that reset to false
+                    if (!usage.isSafe || !usage.hasRead || !usage.hasTrueWrite)
+                        return;
+                    group.add({
+                        scope: path.scope,
+                        currentName: id.name,
+                        baseName: BASE_NAME,
+                    });
+                },
+            });
+            transformationsApplied += group.apply();
+        }
+        return Promise.resolve({
+            nodesVisited,
+            transformationsApplied,
+        });
+    },
+};
+export { renameUseReferenceGuardsV2Transform };

package/dist/transforms/transform-registry.js

@@ -1,11 +1,6 @@
 import { expandBooleanLiteralsTransform } from "./expand-boolean-literals/expand-boolean-literals-transform.js";
-import { expandReturnSequenceTransform } from "./expand-return-sequence/expand-return-sequence-transform.js";
-import { expandSequenceExpressionsTransform } from "./expand-sequence-expressions/expand-sequence-expressions-transform.js";
-import { expandSequenceExpressionsV2Transform } from "./expand-sequence-expressions-v2/expand-sequence-expressions-v2-transform.js";
 import { expandSpecialNumberLiteralsTransform } from "./expand-special-number-literals/expand-special-number-literals-transform.js";
-import { expandSequenceExpressionsV3Transform } from "./expand-sequence-expressions-v3/expand-sequence-expressions-v3-transform.js";
 import { expandSequenceExpressionsV4Transform } from "./expand-sequence-expressions-v4/expand-sequence-expressions-v4-transform.js";
-import { expandThrowSequenceTransform } from "./expand-throw-sequence/expand-throw-sequence-transform.js";
 import { expandUndefinedLiteralsTransform } from "./expand-undefined-literals/expand-undefined-literals-transform.js";
 import { renameCatchParametersTransform } from "./rename-catch-parameters/rename-catch-parameters-transform.js";
 import { renameDestructuredAliasesTransform } from "./rename-destructured-aliases/rename-destructured-aliases-transform.js";
@@ -14,16 +9,12 @@ import { renameLoopIndexVariablesTransform } from "./rename-loop-index-variables
 import { renamePromiseExecutorParametersTransform } from "./rename-promise-executor-parameters/rename-promise-executor-parameters-transform.js";
 import { renameTimeoutIdsTransform } from "./rename-timeout-ids/rename-timeout-ids-transform.js";
 import { renameUseReferenceGuardsTransform } from "./rename-use-reference-guards/rename-use-reference-guards-transform.js";
+import { renameUseReferenceGuardsV2Transform } from "./rename-use-reference-guards-v2/rename-use-reference-guards-v2-transform.js";
 import { splitVariableDeclarationsTransform } from "./split-variable-declarations/split-variable-declarations-transform.js";
 export const transformRegistry = {
     [expandBooleanLiteralsTransform.id]: expandBooleanLiteralsTransform,
-    [expandReturnSequenceTransform.id]: expandReturnSequenceTransform,
-    [expandSequenceExpressionsTransform.id]: expandSequenceExpressionsTransform,
-    [expandSequenceExpressionsV2Transform.id]: expandSequenceExpressionsV2Transform,
-    [expandSequenceExpressionsV3Transform.id]: expandSequenceExpressionsV3Transform,
     [expandSpecialNumberLiteralsTransform.id]: expandSpecialNumberLiteralsTransform,
     [expandSequenceExpressionsV4Transform.id]: expandSequenceExpressionsV4Transform,
-    [expandThrowSequenceTransform.id]: expandThrowSequenceTransform,
     [expandUndefinedLiteralsTransform.id]: expandUndefinedLiteralsTransform,
     [renameCatchParametersTransform.id]: renameCatchParametersTransform,
     [renameDestructuredAliasesTransform.id]: renameDestructuredAliasesTransform,
@@ -32,6 +23,7 @@ export const transformRegistry = {
     [renamePromiseExecutorParametersTransform.id]: renamePromiseExecutorParametersTransform,
     [renameTimeoutIdsTransform.id]: renameTimeoutIdsTransform,
     [renameUseReferenceGuardsTransform.id]: renameUseReferenceGuardsTransform,
+    [renameUseReferenceGuardsV2Transform.id]: renameUseReferenceGuardsV2Transform,
     [splitVariableDeclarationsTransform.id]: splitVariableDeclarationsTransform,
 };
 export const allTransformIds = Object.keys(transformRegistry);

package/package.json

@@ -2,7 +2,7 @@
   "name": "miniread",
   "author": "Łukasz Jerciński",
   "license": "MIT",
-  "version": "1.5.0",
+  "version": "1.7.0",
   "description": "Transform minified JavaScript/TypeScript into a more readable form using deterministic AST-based transforms.",
   "repository": {
     "type": "git",

package/transform-manifest.json

@@ -59,46 +59,6 @@
       "evaluatedAt": "2026-01-22T12:49:10.952Z",
       "notes": "Auto-added by evaluation script. Measured with baseline none: 0.09%."
     },
-    {
-      "id": "expand-return-sequence",
-      "description": "Expands return sequences like `return a(), b();`",
-      "scope": "file",
-      "parallelizable": true,
-      "diffReductionImpact": -0.0012834789830316051,
-      "recommended": false,
-      "evaluatedAt": "2026-01-22T15:19:04.615Z",
-      "notes": "Auto-added by evaluation script. Measured with baseline none: -0.13%. Superseded by expand-sequence-expressions-v2 in the recommended preset."
-    },
-    {
-      "id": "expand-sequence-expressions",
-      "description": "Expands comma operator sequences in statements and variable initializers",
-      "scope": "file",
-      "parallelizable": true,
-      "diffReductionImpact": -0.01282535248485317,
-      "recommended": false,
-      "evaluatedAt": "2026-01-22T17:15:48.528Z",
-      "notes": "Auto-added by evaluation script. Measured with baseline none: -1.28%. Enabled for readability even when line diffs increase. Kept separate from expand-return-sequence to avoid modifying existing transforms and to allow independent enabling."
-    },
-    {
-      "id": "expand-sequence-expressions-v2",
-      "description": "Expands comma operator sequences in returns, statements, and variable initializers",
-      "scope": "file",
-      "parallelizable": true,
-      "diffReductionImpact": -0.014316453068081048,
-      "recommended": false,
-      "evaluatedAt": "2026-01-22T18:22:48.609Z",
-      "notes": "Superseded by expand-sequence-expressions-v3."
-    },
-    {
-      "id": "expand-sequence-expressions-v3",
-      "description": "Expands comma operator sequences in returns, throws, statements, and variable initializers",
-      "scope": "file",
-      "parallelizable": true,
-      "diffReductionImpact": -0.014391951831788763,
-      "recommended": false,
-      "evaluatedAt": "2026-01-23T08:21:23.662Z",
-      "notes": "Supersedes expand-sequence-expressions-v2 in the recommended preset. Measured with baseline none: -1.44%. Enabled for readability even when line diffs increase."
-    },
     {
       "id": "expand-sequence-expressions-v4",
       "description": "Expands comma operator sequences in returns, throws, statements (including control-flow bodies), and variable initializers",
@@ -107,7 +67,7 @@
       "diffReductionImpact": -0.01730809158000035,
       "recommended": true,
       "evaluatedAt": "2026-01-23T10:57:45.082Z",
-      "notes": "Measured with baseline none: -1.73%. Supersedes expand-sequence-expressions-v3 and includes control-flow-body expansion."
+      "notes": "Measured with baseline none: -1.73%. Supersedes all prior sequence expression transforms."
     },
     {
       "id": "rename-use-reference-guards",
@@ -115,9 +75,19 @@
       "scope": "file",
       "parallelizable": true,
       "diffReductionImpact": 0,
-      "recommended": true,
+      "recommended": false,
       "evaluatedAt": "2026-01-22T17:03:19.826Z",
-      "notes": "Auto-added by evaluation script."
+      "notes": "Superseded by rename-use-reference-guards-v2.",
+      "supersededBy": "rename-use-reference-guards-v2"
+    },
+    {
+      "id": "rename-use-reference-guards-v2",
+      "description": "Renames boolean useRef(false) guard variables (including reset-to-false guards) to hasRunRef/hasRunRef2/...",
+      "scope": "file",
+      "parallelizable": true,
+      "diffReductionImpact": 0,
+      "recommended": true,
+      "notes": "Supersedes rename-use-reference-guards and also covers guards that reset to false."
     },
     {
       "id": "rename-timeout-ids",
@@ -125,9 +95,9 @@
       "scope": "file",
       "parallelizable": true,
       "diffReductionImpact": 0.00003774938185385768,
-      "recommended": false,
+      "recommended": true,
       "evaluatedAt": "2026-01-23T10:29:23.279Z",
-      "notes": "Measured with baseline none: 0.00%. Not enabled by default (readability-only)."
+      "notes": "Measured with baseline none: 0.00%. Added to recommended for readability."
     },
     {
       "id": "split-variable-declarations",
@@ -139,16 +109,6 @@
       "evaluatedAt": "2026-01-23T05:45:27.981Z",
       "notes": "Auto-added by evaluation script. Measured with baseline none: -0.28%. Enabled in the recommended preset for readability and to normalize variable declarations even when line diffs increase."
     },
-    {
-      "id": "expand-throw-sequence",
-      "description": "Expands throw sequences like `throw (a(), b)`",
-      "scope": "file",
-      "parallelizable": true,
-      "diffReductionImpact": -0.00007549876370771536,
-      "recommended": false,
-      "evaluatedAt": "2026-01-23T07:48:29.356Z",
-      "notes": "Largely superseded by expand-sequence-expressions-v3 (which also expands throw sequences), but kept for isolated runs and comparison."
-    },
     {
       "id": "rename-promise-executor-parameters",
       "description": "Renames promise-like executor parameters in `new X(executor)` to resolve/reject when usage is high-confidence",

package/dist/transforms/expand-return-sequence/expand-return-sequence-transform.d.ts

@@ -1,2 +0,0 @@
-import { type Transform } from "../../core/types.js";
-export declare const expandReturnSequenceTransform: Transform;