miniread 1.0.0 → 1.2.0

package/dist/transforms/rename-use-reference-guards/get-target-name.js

@@ -0,0 +1,23 @@
+import { isValidBindingIdentifier } from "./is-valid-binding-identifier.js";
+const BASE_NAME = "hasRunRef";
+// Cap retries to avoid pathological loops while handling large bundles.
+const MAX_CANDIDATES = 1000;
+export const getTargetName = (bindingScope, binding) => {
+    const programScope = bindingScope.getProgramParent();
+    for (let index = 0; index < MAX_CANDIDATES; index++) {
+        const candidate = index === 0 ? BASE_NAME : `${BASE_NAME}${index + 1}`;
+        if (!isValidBindingIdentifier(candidate))
+            continue;
+        // Avoid shadowing bindings in parent scopes.
+        if (bindingScope.hasBinding(candidate))
+            continue;
+        if (Object.hasOwn(programScope.globals, candidate))
+            continue;
+        const wouldBeShadowed = binding.referencePaths.some((referencePath) => referencePath.scope !== bindingScope &&
+            referencePath.scope.hasBinding(candidate));
+        if (wouldBeShadowed)
+            continue;
+        return candidate;
+    }
+    return;
+};

package/dist/transforms/rename-use-reference-guards/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/is-use-reference-false-initializer.js

@@ -0,0 +1,25 @@
+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?.type !== "BooleanLiteral")
+        return false;
+    if (argument.value)
+        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/is-valid-binding-identifier.d.ts

@@ -0,0 +1 @@
+export declare const isValidBindingIdentifier: (name: string) => boolean;

package/dist/transforms/rename-use-reference-guards/is-valid-binding-identifier.js

@@ -0,0 +1,10 @@
+import { isIdentifierName, isKeyword, isStrictBindReservedWord, } from "@babel/helper-validator-identifier";
+export const isValidBindingIdentifier = (name) => {
+    if (!isIdentifierName(name))
+        return false;
+    if (isKeyword(name))
+        return false;
+    if (isStrictBindReservedWord(name, true))
+        return false;
+    return true;
+};

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

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

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

@@ -0,0 +1,55 @@
+import { createRequire } from "node:module";
+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 renameUseReferenceGuardsTransform = {
+    id: "rename-use-reference-guards",
+    description: "Renames boolean useRef(false) guard variables to hasRunRef/hasRunRef2/...",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        const { projectGraph } = context;
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const [, fileInfo] of projectGraph.files) {
+            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);
+                    if (!binding)
+                        return;
+                    if (!binding.constant)
+                        return;
+                    const usage = getReferenceUsage(binding);
+                    if (!usage.isSafe ||
+                        !usage.hasRead ||
+                        !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++;
+                },
+            });
+        }
+        return Promise.resolve({
+            nodesVisited,
+            transformationsApplied,
+        });
+    },
+};
+export { renameUseReferenceGuardsTransform };

package/dist/transforms/split-variable-declarations/create-variable-declaration.d.ts

@@ -0,0 +1,2 @@
+import type { VariableDeclaration } from "@babel/types";
+export declare const createVariableDeclarationFromDeclarator: (kind: VariableDeclaration["kind"], declarator: VariableDeclaration["declarations"][number], declare: VariableDeclaration["declare"]) => VariableDeclaration;

package/dist/transforms/split-variable-declarations/create-variable-declaration.js

@@ -0,0 +1,28 @@
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const t = require("@babel/types");
+export const createVariableDeclarationFromDeclarator = (kind, declarator, declare) => {
+    const clonedDeclarator = 
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+    t.cloneNode(declarator, true);
+    const originalDeclarator = declarator;
+    const commentableClone = clonedDeclarator;
+    if (originalDeclarator.leadingComments) {
+        commentableClone.leadingComments = originalDeclarator.leadingComments;
+    }
+    if (originalDeclarator.innerComments) {
+        commentableClone.innerComments = originalDeclarator.innerComments;
+    }
+    if (originalDeclarator.trailingComments) {
+        commentableClone.trailingComments = originalDeclarator.trailingComments;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+    const declaration = t.variableDeclaration(kind, [
+        clonedDeclarator,
+    ]);
+    if (declare) {
+        declaration.declare = declare;
+    }
+    return declaration;
+};

package/dist/transforms/split-variable-declarations/is-safe-to-split-variable-declaration.d.ts

@@ -0,0 +1,3 @@
+import type { NodePath } from "@babel/traverse";
+import type { VariableDeclaration } from "@babel/types";
+export declare const isSafeToSplitVariableDeclaration: (path: NodePath<VariableDeclaration>) => boolean;

package/dist/transforms/split-variable-declarations/is-safe-to-split-variable-declaration.js

@@ -0,0 +1,52 @@
+const getDeclaratorsIfSimpleIdentifiers = (path) => {
+    const declaratorPaths = path.get("declarations");
+    if (!Array.isArray(declaratorPaths))
+        return [];
+    const declarators = [];
+    for (const declaratorPath of declaratorPaths) {
+        if (!declaratorPath.isVariableDeclarator())
+            return [];
+        const idPath = declaratorPath.get("id");
+        if (!idPath.isIdentifier())
+            return [];
+        declarators.push({ declaratorPath, name: idPath.node.name });
+    }
+    return declarators;
+};
+const initializerReferencesAnyName = (initPath, names) => {
+    let found = false;
+    initPath.traverse({
+        Identifier(identifierPath) {
+            if (!identifierPath.isReferencedIdentifier())
+                return;
+            if (!names.has(identifierPath.node.name))
+                return;
+            found = true;
+            identifierPath.stop();
+        },
+    });
+    return found;
+};
+export const isSafeToSplitVariableDeclaration = (path) => {
+    const { kind } = path.node;
+    if (kind === "var")
+        return true;
+    const declarators = getDeclaratorsIfSimpleIdentifiers(path);
+    if (declarators.length < 2)
+        return false;
+    for (let index = 0; index < declarators.length - 1; index++) {
+        const declarator = declarators[index];
+        if (!declarator)
+            continue;
+        const laterNames = new Set(declarators.slice(index + 1).map((item) => item.name));
+        if (laterNames.size === 0)
+            continue;
+        const initPath = declarator.declaratorPath.get("init");
+        if (!initPath.node)
+            continue;
+        if (initializerReferencesAnyName(initPath, laterNames)) {
+            return false;
+        }
+    }
+    return true;
+};

package/dist/transforms/split-variable-declarations/split-variable-declarations-transform.d.ts

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

package/dist/transforms/split-variable-declarations/split-variable-declarations-transform.js

@@ -0,0 +1,81 @@
+import { createRequire } from "node:module";
+import { createVariableDeclarationFromDeclarator } from "./create-variable-declaration.js";
+import { isSafeToSplitVariableDeclaration } from "./is-safe-to-split-variable-declaration.js";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const traverse = require("@babel/traverse").default;
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const t = require("@babel/types");
+const isSupportedStatementContainer = (path) => {
+    const parentPath = path.parentPath;
+    if (!parentPath)
+        return false;
+    return (parentPath.isProgram() ||
+        parentPath.isBlockStatement() ||
+        parentPath.isSwitchCase());
+};
+const transferSplitComments = (original, first, last) => {
+    if (first && original.leadingComments) {
+        first.leadingComments = original.leadingComments;
+    }
+    if (first && original.innerComments) {
+        first.innerComments = original.innerComments;
+    }
+    if (last && original.trailingComments) {
+        last.trailingComments = original.trailingComments;
+    }
+};
+export const splitVariableDeclarationsTransform = {
+    id: "split-variable-declarations",
+    description: "Splits multi-declarator variable declarations into separate statements (statement position and exports)",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        const { projectGraph } = context;
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const [, fileInfo] of projectGraph.files) {
+            traverse(fileInfo.ast, {
+                ExportNamedDeclaration(path) {
+                    nodesVisited++;
+                    const declarationPath = path.get("declaration");
+                    if (!declarationPath.isVariableDeclaration())
+                        return;
+                    if (declarationPath.node.declarations.length < 2)
+                        return;
+                    if (!isSafeToSplitVariableDeclaration(declarationPath))
+                        return;
+                    const declaration = declarationPath.node;
+                    const statements = declaration.declarations.map((declarator) => {
+                        const newDeclaration = createVariableDeclarationFromDeclarator(declaration.kind, declarator, declaration.declare);
+                        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+                        const exportDeclaration = t.exportNamedDeclaration(newDeclaration, []);
+                        exportDeclaration.exportKind =
+                            path.node.exportKind;
+                        return exportDeclaration;
+                    });
+                    transferSplitComments(path.node, statements.at(0), statements.at(-1));
+                    path.replaceWithMultiple(statements);
+                    path.skip();
+                    transformationsApplied++;
+                },
+                VariableDeclaration(path) {
+                    nodesVisited++;
+                    if (!isSupportedStatementContainer(path))
+                        return;
+                    const declaration = path.node;
+                    if (declaration.declarations.length < 2)
+                        return;
+                    if (!isSafeToSplitVariableDeclaration(path))
+                        return;
+                    const statements = declaration.declarations.map((declarator) => createVariableDeclarationFromDeclarator(declaration.kind, declarator, declaration.declare));
+                    transferSplitComments(declaration, statements.at(0), statements.at(-1));
+                    path.replaceWithMultiple(statements);
+                    path.skip();
+                    transformationsApplied++;
+                },
+            });
+        }
+        return Promise.resolve({ nodesVisited, transformationsApplied });
+    },
+};

package/dist/transforms/transform-presets.js

@@ -3,7 +3,7 @@ import * as z from "zod";
 const TransformManifestEntry = z
     .object({
     id: z.string().min(1),
-    enabledByDefault: z.boolean(),
+    recommended: z.boolean(),
 })
     .loose();
 const TransformManifest = z
@@ -14,6 +14,6 @@ const TransformManifest = z
 const transformManifest = TransformManifest.parse(transformManifestJson);
 export const transformPresets = {
     recommended: transformManifest.transforms
-        .filter((transform) => transform.enabledByDefault)
+        .filter((transform) => transform.recommended)
         .map((transform) => transform.id),
 };

package/dist/transforms/transform-registry.js

@@ -1,15 +1,31 @@
-import { addPrefixTransform } from "./add-prefix/add-prefix-transform.js";
-import { addSuffixTransform } from "./add-suffix/add-suffix-transform.js";
 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 { expandSequenceExpressionsV3Transform } from "./expand-sequence-expressions-v3/expand-sequence-expressions-v3-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";
 import { renameLoopIndexVariablesTransform } from "./rename-loop-index-variables/rename-loop-index-variables-transform.js";
+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 { splitVariableDeclarationsTransform } from "./split-variable-declarations/split-variable-declarations-transform.js";
 export const transformRegistry = {
-    [addPrefixTransform.id]: addPrefixTransform,
-    [addSuffixTransform.id]: addSuffixTransform,
     [expandBooleanLiteralsTransform.id]: expandBooleanLiteralsTransform,
+    [expandReturnSequenceTransform.id]: expandReturnSequenceTransform,
+    [expandSequenceExpressionsTransform.id]: expandSequenceExpressionsTransform,
+    [expandSequenceExpressionsV2Transform.id]: expandSequenceExpressionsV2Transform,
+    [expandSequenceExpressionsV3Transform.id]: expandSequenceExpressionsV3Transform,
+    [expandThrowSequenceTransform.id]: expandThrowSequenceTransform,
     [expandUndefinedLiteralsTransform.id]: expandUndefinedLiteralsTransform,
     [renameCatchParametersTransform.id]: renameCatchParametersTransform,
+    [renameDestructuredAliasesTransform.id]: renameDestructuredAliasesTransform,
     [renameLoopIndexVariablesTransform.id]: renameLoopIndexVariablesTransform,
+    [renamePromiseExecutorParametersTransform.id]: renamePromiseExecutorParametersTransform,
+    [renameTimeoutIdsTransform.id]: renameTimeoutIdsTransform,
+    [renameUseReferenceGuardsTransform.id]: renameUseReferenceGuardsTransform,
+    [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.0.0",
+  "version": "1.2.0",
   "description": "Transform minified JavaScript/TypeScript into a more readable form using deterministic AST-based transforms.",
   "repository": {
     "type": "git",
@@ -33,12 +33,34 @@
     "README.md",
     "LICENSE"
   ],
+  "scripts": {
+    "prepare": "git config core.hooksPath .githooks",
+    "prepublishOnly": "pnpm run rebuild",
+    "build": "tsc -p tsconfig.app.json",
+    "check": "pnpm -s run rebuild && node bin/miniread-evaluate -- --check",
+    "clean": "rm -rf dist *.tsbuildinfo",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "fta": "fta-check",
+    "knip": "knip",
+    "lint": "eslint",
+    "miniread": "pnpm -s run rebuild && node bin/miniread",
+    "miniread-evaluate": "pnpm -s run rebuild && node bin/miniread-evaluate",
+    "miniread-sample": "pnpm -s run rebuild && node bin/miniread-sample",
+    "rebuild": "pnpm run clean && pnpm run build",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "test:watch": "vitest",
+    "typecheck": "tsc -b --noEmit"
+  },
   "keywords": [],
+  "packageManager": "pnpm@10.28.1",
   "engines": {
     "node": ">=22.14.0"
   },
   "dependencies": {
     "@babel/generator": "^7.28.6",
+    "@babel/helper-validator-identifier": "^7.28.5",
     "@babel/parser": "^7.28.6",
     "@babel/traverse": "^7.28.6",
     "@babel/types": "^7.28.6",
@@ -46,14 +68,15 @@
     "commander": "^14.0.2",
     "env-paths": "^3.0.0",
     "p-queue": "^9.1.0",
-    "zod": "^4.3.5"
+    "zod": "^4.3.6"
   },
   "devDependencies": {
     "@total-typescript/ts-reset": "^0.6.1",
     "@types/babel__generator": "^7.27.0",
+    "@types/babel__helper-validator-identifier": "^7.15.2",
     "@types/babel__traverse": "^7.28.0",
-    "@types/node": "^25.0.9",
-    "@vitest/coverage-v8": "^4.0.17",
+    "@types/node": "^25.0.10",
+    "@vitest/coverage-v8": "^4.0.18",
     "eslint": "^9.39.2",
     "eslint-config-axkit": "^1.1.0",
     "fta-check": "^1.5.1",
@@ -62,23 +85,6 @@
     "prettier": "3.8.0",
     "semantic-release": "^25.0.2",
     "typescript": "^5.9.3",
-    "vitest": "^4.0.17"
-  },
-  "scripts": {
-    "build": "tsc -p tsconfig.app.json",
-    "clean": "rm -rf dist *.tsbuildinfo",
-    "format": "prettier --write .",
-    "format:check": "prettier --check .",
-    "fta": "fta-check",
-    "knip": "knip",
-    "lint": "eslint",
-    "rebuild": "pnpm run clean && pnpm run build",
-    "miniread": "pnpm -s run rebuild && node bin/miniread",
-    "test": "vitest run",
-    "test:coverage": "vitest run --coverage",
-    "test:watch": "vitest",
-    "miniread-evaluate": "pnpm -s run rebuild && node bin/miniread-evaluate",
-    "miniread-sample": "pnpm -s run rebuild && node bin/miniread-sample",
-    "typecheck": "tsc -b --noEmit"
+    "vitest": "^4.0.18"
   }
-}
+}

package/transform-manifest.json

@@ -1,70 +1,150 @@
 {
   "transforms": [
-    {
-      "id": "add-prefix",
-      "description": "Adds 'renamed_' prefix to variable and function declarations",
-      "iteration": 0,
-      "scope": "file",
-      "parallelizable": true,
-      "diffReductionImpact": 0,
-      "enabledByDefault": false,
-      "notes": "Example transform for testing infrastructure"
-    },
-    {
-      "id": "add-suffix",
-      "description": "Adds '_end' suffix to variable and function declarations",
-      "iteration": 0,
-      "scope": "file",
-      "parallelizable": true,
-      "diffReductionImpact": 0,
-      "enabledByDefault": false,
-      "notes": "Example transform for testing infrastructure"
-    },
     {
       "id": "expand-boolean-literals",
       "description": "Expands !0 to true and !1 to false",
-      "iteration": 1,
       "scope": "file",
       "parallelizable": true,
       "diffReductionImpact": 0,
-      "enabledByDefault": true,
+      "recommended": true,
+      "evaluatedAt": "2026-01-21T15:01:23.708Z",
       "notes": "Improves readability but does not reduce diffs (boolean literals are already deterministic)"
     },
     {
       "id": "expand-undefined-literals",
       "description": "Expands void 0 to undefined (when undefined is not shadowed)",
-      "iteration": 2,
       "scope": "file",
       "parallelizable": true,
       "diffReductionImpact": 0,
-      "enabledByDefault": true,
+      "recommended": true,
+      "evaluatedAt": "2026-01-21T16:27:42.316Z",
       "notes": "Auto-added by evaluation script."
     },
     {
       "id": "rename-loop-index-variables",
       "description": "Renames numeric for-loop counters to index/index2/... based on nesting depth",
-      "iteration": 3,
       "scope": "file",
       "parallelizable": true,
       "diffReductionImpact": 0,
-      "enabledByDefault": true,
+      "recommended": true,
+      "evaluatedAt": "2026-01-21T21:06:19.512Z",
       "notes": "Auto-added by evaluation script."
     },
     {
       "id": "rename-catch-parameters",
       "description": "Renames minified catch clause parameters to caughtError/caughtError2/...",
-      "iteration": 4,
+      "scope": "file",
+      "parallelizable": true,
+      "diffReductionImpact": 0.0007738623280043599,
+      "recommended": true,
+      "evaluatedAt": "2026-01-23T07:48:59.087Z",
+      "notes": "Auto-added by evaluation script."
+    },
+    {
+      "id": "rename-destructured-aliases",
+      "description": "Renames destructuring aliases to match property names (e.g., { foo: x } → { foo })",
+      "scope": "file",
+      "parallelizable": true,
+      "diffReductionImpact": 0.000943734546346775,
+      "recommended": true,
+      "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": true,
+      "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": "rename-use-reference-guards",
+      "description": "Renames boolean useRef(false) guard variables to hasRunRef/hasRunRef2/...",
       "scope": "file",
       "parallelizable": true,
       "diffReductionImpact": 0,
-      "enabledByDefault": true,
+      "recommended": true,
+      "evaluatedAt": "2026-01-22T17:03:19.826Z",
+      "notes": "Auto-added by evaluation script."
+    },
+    {
+      "id": "rename-timeout-ids",
+      "description": "Renames setTimeout handle variables to timeoutId/timeoutId2/... when usage is only clearTimeout(...)",
+      "scope": "file",
+      "parallelizable": true,
+      "diffReductionImpact": 0.00003774938185385768,
+      "recommended": false,
+      "evaluatedAt": "2026-01-23T10:29:23.279Z",
+      "notes": "Measured with baseline none: 0.00%. Not enabled by default (readability-only)."
+    },
+    {
+      "id": "split-variable-declarations",
+      "description": "Splits multi-declarator variable declarations into separate statements",
+      "scope": "file",
+      "parallelizable": true,
+      "diffReductionImpact": -0.0027651422207961573,
+      "recommended": true,
+      "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",
+      "scope": "file",
+      "parallelizable": true,
+      "diffReductionImpact": 0,
+      "recommended": true,
+      "evaluatedAt": "2026-01-22T21:39:53.578Z",
       "notes": "Auto-added by evaluation script."
     }
   ],
   "presetStats": {
     "recommended": {
-      "diffReductionImpact": 0,
-      "notes": "Auto-updated by evaluation when running with baseline none and the recommended preset."
+      "diffReductionImpact": 0.00560578320530003,
+      "notes": "Measured with baseline none: 0.56%."
     }
   }
 }

package/dist/transforms/add-prefix/add-prefix-transform.d.ts

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