miniread 1.119.0 → 1.120.0

package/dist/scripts/evaluate/compute-directory-diff.js

@@ -60,8 +60,14 @@ export const computeDirectoryDiff = async (options) => {
             }
             if (!outputStream)
                 continue;
-            if (outputStreamError)
+            if (outputStreamError) {
+                if (outputPath &&
+                    isErrnoException(outputStreamError) &&
+                    outputStreamError.code === "EEXIST") {
+                    throw new Error(`Refusing to overwrite existing diff output file: ${outputPath}. Re-run with --overwrite to replace.`);
+                }
                 throw outputStreamError;
+            }
             if (outputStream.write(outputLine))
                 continue;
             await once(outputStream, "drain");
@@ -71,9 +77,9 @@ export const computeDirectoryDiff = async (options) => {
         rl.close();
     }
     if (outputStreamError) {
-        if (outputPath && isErrnoException(outputStreamError)) {
-            if (outputStreamError.code !== "EEXIST")
-                throw outputStreamError;
+        if (outputPath &&
+            isErrnoException(outputStreamError) &&
+            outputStreamError.code === "EEXIST") {
             throw new Error(`Refusing to overwrite existing diff output file: ${outputPath}. Re-run with --overwrite to replace.`);
         }
         throw outputStreamError;

package/dist/transforms/preset-stats.json

@@ -1,6 +1,6 @@
 {
     "recommended": {
-        "diffSizePercent": 26.01296443285331,
-        "notes": "Measured with baseline none: 26.01% of original diff."
+        "diffSizePercent": 23.705446573685602,
+        "notes": "Measured with baseline none: 23.71% of original diff."
     }
 }

package/dist/transforms-by-id/expand-boolean-literals/expand-boolean-literals-transform.js

@@ -1,7 +1,12 @@
 import { createRequire } from "node:module";
 import { getFilesToProcess, } from "../../core/types.js";
 import { hasGlobalBooleanRebinding } from "./detect-global-boolean-rebinding.js";
-import { resolveBooleanNegationValue, resolveDoubleNegationValue, } from "./resolve-literal-boolean-value.js";
+import { tryExpandDoubleNegationBooleanCall } from "./try-expand-double-negation-boolean-call.js";
+import { tryExpandDoubleNegatedMembershipExpression } from "./try-expand-double-negated-membership-expression.js";
+import { tryExpandNegatedBinaryExpression } from "./try-expand-negated-binary-expression.js";
+import { tryExpandNegatedSignedNumericLiteral } from "./try-expand-negated-signed-numeric-literal.js";
+import { tryExpandResolvedBooleanNegation } from "./try-expand-resolved-boolean-negation.js";
+import { tryExpandResolvedDoubleNegation } from "./try-expand-resolved-double-negation.js";
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 const traverse = require("@babel/traverse").default;
@@ -20,73 +25,45 @@ export const expandBooleanLiteralsTransform = {
                 UnaryExpression(path) {
                     nodesVisited++;
                     const { operator, argument } = path.node;
-                    if (operator !== "!") {
+                    if (operator !== "!")
                         return;
-                    }
-                    if (path.findParent((parentPath) => parentPath.isWithStatement())) {
-                        return;
-                    }
-                    const booleanNegationResolution = resolveBooleanNegationValue(path, argument);
-                    if (booleanNegationResolution !== undefined) {
-                        if (booleanNegationResolution.kind === "literal" &&
-                            !path.get("argument").isPure()) {
-                            return;
-                        }
-                        path.replaceWith(t.booleanLiteral(booleanNegationResolution.value));
+                    const isInsideWithStatement = path.findParent((parentPath) => parentPath.isWithStatement()) !==
+                        null;
+                    if (tryExpandResolvedBooleanNegation(path, {
+                        isInsideWithStatement,
+                        t,
+                    })) {
                         transformationsApplied++;
                         return;
                     }
-                    if (argument.type === "UnaryExpression" &&
-                        argument.operator === "!" &&
-                        argument.argument.type === "NumericLiteral") {
-                        const booleanValue = argument.argument.value !== 0;
-                        path.replaceWith(t.booleanLiteral(booleanValue));
+                    if (tryExpandNegatedBinaryExpression(path, t)) {
                         transformationsApplied++;
                         return;
                     }
-                    if (argument.type === "BinaryExpression" &&
-                        (argument.operator === "in" || argument.operator === "instanceof")) {
-                        path.replaceWith(t.binaryExpression("===", t.parenthesizedExpression(t.cloneNode(argument, true)), t.booleanLiteral(false)));
+                    if (tryExpandDoubleNegatedMembershipExpression(path, t)) {
                         transformationsApplied++;
                         return;
                     }
-                    if (argument.type === "UnaryExpression" &&
-                        argument.operator === "!") {
-                        const doubleNegationResolution = resolveDoubleNegationValue(path, argument.argument);
-                        if (doubleNegationResolution !== undefined) {
-                            if (doubleNegationResolution.kind === "literal" &&
-                                !path.get("argument.argument").isPure()) {
-                                return;
-                            }
-                            path.replaceWith(t.booleanLiteral(doubleNegationResolution.value));
-                            transformationsApplied++;
-                            return;
-                        }
-                    }
-                    if (argument.type === "UnaryExpression" &&
-                        argument.operator === "!") {
-                        if (path.scope.hasBinding("Boolean", true)) {
-                            return;
-                        }
-                        if (hasGlobalBooleanRebindingInFile) {
-                            return;
-                        }
-                        path.replaceWith(t.callExpression(t.identifier("Boolean"), [
-                            t.cloneNode(argument.argument, true),
-                        ]));
+                    if (tryExpandResolvedDoubleNegation(path, {
+                        isInsideWithStatement,
+                        t,
+                    })) {
                         transformationsApplied++;
                         return;
                     }
-                    if (argument.type === "UnaryExpression" &&
-                        (argument.operator === "+" || argument.operator === "-") &&
-                        argument.argument.type === "NumericLiteral") {
-                        const numericValue = argument.operator === "-"
-                            ? -argument.argument.value
-                            : argument.argument.value;
-                        const booleanValue = numericValue === 0;
-                        path.replaceWith(t.booleanLiteral(booleanValue));
+                    if (tryExpandDoubleNegationBooleanCall(path, {
+                        hasGlobalBooleanRebindingInFile,
+                        isInsideWithStatement,
+                        t,
+                    })) {
                         transformationsApplied++;
+                        return;
                     }
+                    if (argument.type !== "UnaryExpression")
+                        return;
+                    if (!tryExpandNegatedSignedNumericLiteral(path, t))
+                        return;
+                    transformationsApplied++;
                 },
             });
         }

package/dist/transforms-by-id/expand-boolean-literals/get-inverted-binary-operator.d.ts

@@ -0,0 +1,2 @@
+import type { BinaryExpression } from "@babel/types";
+export declare const getInvertedBinaryOperator: (operator: BinaryExpression["operator"]) => BinaryExpression["operator"] | undefined;

package/dist/transforms-by-id/expand-boolean-literals/get-inverted-binary-operator.js

@@ -0,0 +1,11 @@
+export const getInvertedBinaryOperator = (operator) => {
+    if (operator === "===")
+        return "!==";
+    if (operator === "!==")
+        return "===";
+    if (operator === "==")
+        return "!=";
+    if (operator === "!=")
+        return "==";
+    return undefined;
+};

package/dist/transforms-by-id/expand-boolean-literals/manifest.json

@@ -3,9 +3,9 @@
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
             "diffSizePercent": 100,
-            "evaluatedAt": "2026-02-10T20:27:40.370Z",
-            "changedLines": 37534,
-            "durationSeconds": 40.372261375,
+            "evaluatedAt": "2026-02-22T15:30:29.948Z",
+            "changedLines": 37562,
+            "durationSeconds": 41.198199708,
             "stableNames": 1357
         }
     },

package/dist/transforms-by-id/expand-boolean-literals/try-expand-double-negated-membership-expression.d.ts

@@ -0,0 +1,4 @@
+import type { NodePath } from "@babel/traverse";
+import type * as BabelTypes from "@babel/types";
+import type { UnaryExpression } from "@babel/types";
+export declare const tryExpandDoubleNegatedMembershipExpression: (path: NodePath<UnaryExpression>, t: typeof BabelTypes) => boolean;

package/dist/transforms-by-id/expand-boolean-literals/try-expand-double-negated-membership-expression.js

@@ -0,0 +1,16 @@
+const isMembershipOperator = (operator) => {
+    return operator === "in" || operator === "instanceof";
+};
+export const tryExpandDoubleNegatedMembershipExpression = (path, t) => {
+    const { argument } = path.node;
+    if (argument.type !== "UnaryExpression" || argument.operator !== "!") {
+        return false;
+    }
+    const innerArgument = argument.argument;
+    if (innerArgument.type !== "BinaryExpression")
+        return false;
+    if (!isMembershipOperator(innerArgument.operator))
+        return false;
+    path.replaceWith(t.binaryExpression("===", t.parenthesizedExpression(t.cloneNode(innerArgument, true)), t.booleanLiteral(true)));
+    return true;
+};

package/dist/transforms-by-id/expand-boolean-literals/try-expand-double-negation-boolean-call.d.ts

@@ -0,0 +1,10 @@
+import type { NodePath } from "@babel/traverse";
+import type * as BabelTypes from "@babel/types";
+import type { UnaryExpression } from "@babel/types";
+type TryExpandDoubleNegationBooleanCallContext = {
+    hasGlobalBooleanRebindingInFile: boolean;
+    isInsideWithStatement: boolean;
+    t: typeof BabelTypes;
+};
+export declare const tryExpandDoubleNegationBooleanCall: (path: NodePath<UnaryExpression>, context: TryExpandDoubleNegationBooleanCallContext) => boolean;
+export {};

package/dist/transforms-by-id/expand-boolean-literals/try-expand-double-negation-boolean-call.js

@@ -0,0 +1,16 @@
+export const tryExpandDoubleNegationBooleanCall = (path, context) => {
+    const { argument } = path.node;
+    if (argument.type !== "UnaryExpression" || argument.operator !== "!") {
+        return false;
+    }
+    if (context.isInsideWithStatement)
+        return false;
+    if (path.scope.hasBinding("Boolean", true))
+        return false;
+    if (context.hasGlobalBooleanRebindingInFile)
+        return false;
+    path.replaceWith(context.t.callExpression(context.t.identifier("Boolean"), [
+        context.t.cloneNode(argument.argument, true),
+    ]));
+    return true;
+};

package/dist/transforms-by-id/expand-boolean-literals/try-expand-negated-binary-expression.d.ts

@@ -0,0 +1,4 @@
+import type { NodePath } from "@babel/traverse";
+import type * as BabelTypes from "@babel/types";
+import type { UnaryExpression } from "@babel/types";
+export declare const tryExpandNegatedBinaryExpression: (path: NodePath<UnaryExpression>, t: typeof BabelTypes) => boolean;

package/dist/transforms-by-id/expand-boolean-literals/try-expand-negated-binary-expression.js

@@ -0,0 +1,34 @@
+import { getInvertedBinaryOperator } from "./get-inverted-binary-operator.js";
+const isRelationalOperator = (operator) => {
+    return (operator === "<" ||
+        operator === "<=" ||
+        operator === ">" ||
+        operator === ">=");
+};
+const isMembershipOperator = (operator) => {
+    return operator === "in" || operator === "instanceof";
+};
+const replaceBinaryExpressionWithBooleanComparison = (path, t, value) => {
+    const binaryArgument = path.node.argument;
+    if (binaryArgument.type !== "BinaryExpression")
+        return;
+    path.replaceWith(t.binaryExpression("===", t.parenthesizedExpression(t.cloneNode(binaryArgument, true)), t.booleanLiteral(value)));
+};
+export const tryExpandNegatedBinaryExpression = (path, t) => {
+    const { argument } = path.node;
+    if (argument.type !== "BinaryExpression")
+        return false;
+    const invertedOperator = getInvertedBinaryOperator(argument.operator);
+    if (invertedOperator !== undefined) {
+        path.replaceWith(t.binaryExpression(invertedOperator, t.cloneNode(argument.left, true), t.cloneNode(argument.right, true)));
+        return true;
+    }
+    if (isRelationalOperator(argument.operator)) {
+        replaceBinaryExpressionWithBooleanComparison(path, t, false);
+        return true;
+    }
+    if (!isMembershipOperator(argument.operator))
+        return false;
+    replaceBinaryExpressionWithBooleanComparison(path, t, false);
+    return true;
+};

package/dist/transforms-by-id/expand-boolean-literals/try-expand-negated-signed-numeric-literal.d.ts

@@ -0,0 +1,4 @@
+import type { NodePath } from "@babel/traverse";
+import type * as BabelTypes from "@babel/types";
+import type { UnaryExpression } from "@babel/types";
+export declare const tryExpandNegatedSignedNumericLiteral: (path: NodePath<UnaryExpression>, t: typeof BabelTypes) => boolean;

package/dist/transforms-by-id/expand-boolean-literals/try-expand-negated-signed-numeric-literal.js

@@ -0,0 +1,14 @@
+export const tryExpandNegatedSignedNumericLiteral = (path, t) => {
+    const { argument } = path.node;
+    if (argument.type !== "UnaryExpression")
+        return false;
+    if (argument.operator !== "+" && argument.operator !== "-")
+        return false;
+    if (argument.argument.type !== "NumericLiteral")
+        return false;
+    const numericValue = argument.operator === "-"
+        ? -argument.argument.value
+        : argument.argument.value;
+    path.replaceWith(t.booleanLiteral(numericValue === 0));
+    return true;
+};

package/dist/transforms-by-id/expand-boolean-literals/try-expand-resolved-boolean-negation.d.ts

@@ -0,0 +1,9 @@
+import type { NodePath } from "@babel/traverse";
+import type * as BabelTypes from "@babel/types";
+import type { UnaryExpression } from "@babel/types";
+type TryExpandResolvedBooleanNegationContext = {
+    isInsideWithStatement: boolean;
+    t: typeof BabelTypes;
+};
+export declare const tryExpandResolvedBooleanNegation: (path: NodePath<UnaryExpression>, context: TryExpandResolvedBooleanNegationContext) => boolean;
+export {};

package/dist/transforms-by-id/expand-boolean-literals/try-expand-resolved-boolean-negation.js

@@ -0,0 +1,14 @@
+import { resolveBooleanNegationValue } from "./resolve-literal-boolean-value.js";
+export const tryExpandResolvedBooleanNegation = (path, context) => {
+    const resolution = resolveBooleanNegationValue(path, path.node.argument);
+    if (resolution === undefined)
+        return false;
+    if (context.isInsideWithStatement && resolution.kind !== "literal") {
+        return false;
+    }
+    if (resolution.kind === "literal" && !path.get("argument").isPure()) {
+        return false;
+    }
+    path.replaceWith(context.t.booleanLiteral(resolution.value));
+    return true;
+};

package/dist/transforms-by-id/expand-boolean-literals/try-expand-resolved-double-negation.d.ts

@@ -0,0 +1,9 @@
+import type { NodePath } from "@babel/traverse";
+import type * as BabelTypes from "@babel/types";
+import type { UnaryExpression } from "@babel/types";
+type TryExpandResolvedDoubleNegationContext = {
+    isInsideWithStatement: boolean;
+    t: typeof BabelTypes;
+};
+export declare const tryExpandResolvedDoubleNegation: (path: NodePath<UnaryExpression>, context: TryExpandResolvedDoubleNegationContext) => boolean;
+export {};

package/dist/transforms-by-id/expand-boolean-literals/try-expand-resolved-double-negation.js

@@ -0,0 +1,19 @@
+import { resolveDoubleNegationValue } from "./resolve-literal-boolean-value.js";
+export const tryExpandResolvedDoubleNegation = (path, context) => {
+    const { argument } = path.node;
+    if (argument.type !== "UnaryExpression" || argument.operator !== "!") {
+        return false;
+    }
+    const resolution = resolveDoubleNegationValue(path, argument.argument);
+    if (resolution === undefined)
+        return false;
+    if (context.isInsideWithStatement && resolution.kind !== "literal") {
+        return false;
+    }
+    if (resolution.kind === "literal" &&
+        !path.get("argument.argument").isPure()) {
+        return false;
+    }
+    path.replaceWith(context.t.booleanLiteral(resolution.value));
+    return true;
+};

package/dist/transforms-by-id/rename-asap-wrappers/get-asap-wrapper-details.d.ts

@@ -1,5 +1,5 @@
 import type { ArrowFunctionExpression, FunctionExpression } from "@babel/types";
 export declare const getAsapWrapperDetails: (init: ArrowFunctionExpression | FunctionExpression) => {
     outerParameterName: string;
-    innerParameterName: string;
+    innerParameterName: string | undefined;
 } | undefined;

package/dist/transforms-by-id/rename-asap-wrappers/get-asap-wrapper-details.js

@@ -1,12 +1,16 @@
+import { getForwardedArgumentsIdentifier } from "./get-forwarded-arguments-identifier.js";
+import { hasExactlyOneLexicalReturnStatement } from "./has-exactly-one-lexical-return-statement.js";
+const SCHEDULER_METHOD_NAMES = new Set(["asap", "nextTick", "queueMicrotask"]);
 const isAsapCallee = (call) => {
     const callee = call.callee;
     if (callee.type === "Identifier") {
-        return callee.name === "asap";
+        return SCHEDULER_METHOD_NAMES.has(callee.name);
     }
     if (callee.type === "MemberExpression") {
         if (callee.computed)
             return false;
-        return (callee.property.type === "Identifier" && callee.property.name === "asap");
+        return (callee.property.type === "Identifier" &&
+            SCHEDULER_METHOD_NAMES.has(callee.property.name));
     }
     return false;
 };
@@ -19,10 +23,13 @@ const getIdentifierName = (node) => {
     return undefined;
 };
 const getReturnCallExpression = (block) => {
-    if (block.body.length !== 1)
+    const returnStatements = block.body.filter((statement) => statement.type === "ReturnStatement");
+    if (returnStatements.length !== 1)
         return undefined;
-    const statement = block.body[0];
-    if (statement?.type !== "ReturnStatement")
+    if (!hasExactlyOneLexicalReturnStatement(block))
+        return undefined;
+    const statement = returnStatements.at(0);
+    if (!statement)
         return undefined;
     const argument = statement.argument;
     if (argument?.type !== "CallExpression")
@@ -38,10 +45,13 @@ const getFunctionCallExpression = (functionNode) => {
     return undefined;
 };
 const getReturnedFunctionExpression = (block) => {
-    if (block.body.length !== 1)
+    const returnStatements = block.body.filter((statement) => statement.type === "ReturnStatement");
+    if (returnStatements.length !== 1)
+        return undefined;
+    if (!hasExactlyOneLexicalReturnStatement(block))
         return undefined;
-    const statement = block.body[0];
-    if (statement?.type !== "ReturnStatement")
+    const statement = returnStatements.at(0);
+    if (!statement)
         return undefined;
     const argument = statement.argument;
     if (argument?.type !== "ArrowFunctionExpression" &&
@@ -60,6 +70,16 @@ const getInnerWrapperFunction = (init) => {
     }
     return getReturnedFunctionExpression(init.body);
 };
+const getInnerParameterName = (inner) => {
+    if (inner.params.length === 0)
+        return undefined;
+    if (inner.params.length !== 1)
+        return undefined;
+    const innerParameter = inner.params[0];
+    if (!innerParameter)
+        return undefined;
+    return getIdentifierName(innerParameter);
+};
 export const getAsapWrapperDetails = (init) => {
     if (init.params.length !== 1)
         return undefined;
@@ -69,13 +89,8 @@ export const getAsapWrapperDetails = (init) => {
     const inner = getInnerWrapperFunction(init);
     if (!inner)
         return undefined;
-    if (inner.params.length !== 1)
-        return undefined;
-    const innerParameter = inner.params[0];
-    if (!innerParameter)
-        return undefined;
-    const restParameterName = getIdentifierName(innerParameter);
-    if (!restParameterName)
+    const innerParameterName = getInnerParameterName(inner);
+    if (inner.params.length > 0 && !innerParameterName)
         return undefined;
     const innerCallExpression = getFunctionCallExpression(inner);
     if (!innerCallExpression)
@@ -94,23 +109,23 @@ export const getAsapWrapperDetails = (init) => {
     const callbackCallExpression = getFunctionCallExpression(callback);
     if (!callbackCallExpression)
         return undefined;
-    const calledFunction = callbackCallExpression.callee;
-    if (calledFunction.type !== "Identifier")
-        return undefined;
-    if (calledFunction.name !== outerParameter.name)
-        return undefined;
-    const callbackArguments = callbackCallExpression.arguments;
-    if (callbackArguments.length !== 1)
-        return undefined;
-    const spread = callbackArguments[0];
-    if (spread?.type !== "SpreadElement")
-        return undefined;
-    if (spread.argument.type !== "Identifier")
-        return undefined;
-    if (spread.argument.name !== restParameterName)
+    const forwardedArgumentsName = getForwardedArgumentsIdentifier(callbackCallExpression, outerParameter.name);
+    if (!forwardedArgumentsName)
         return undefined;
+    if (innerParameterName) {
+        if (forwardedArgumentsName !== innerParameterName)
+            return undefined;
+    }
+    else {
+        if (forwardedArgumentsName !== "arguments")
+            return undefined;
+        if (callback.type !== "ArrowFunctionExpression")
+            return undefined;
+        if (inner.type !== "FunctionExpression")
+            return undefined;
+    }
     return {
         outerParameterName: outerParameter.name,
-        innerParameterName: restParameterName,
+        innerParameterName,
     };
 };

package/dist/transforms-by-id/rename-asap-wrappers/get-forwarded-arguments-identifier.d.ts

@@ -0,0 +1,2 @@
+import type { CallExpression } from "@babel/types";
+export declare const getForwardedArgumentsIdentifier: (callbackCallExpression: CallExpression, outerParameterName: string) => string | undefined;

package/dist/transforms-by-id/rename-asap-wrappers/get-forwarded-arguments-identifier.js

@@ -0,0 +1,41 @@
+export const getForwardedArgumentsIdentifier = (callbackCallExpression, outerParameterName) => {
+    const callee = callbackCallExpression.callee;
+    if (callee.type === "Identifier") {
+        if (callee.name !== outerParameterName)
+            return undefined;
+        if (callbackCallExpression.arguments.length !== 1)
+            return undefined;
+        const spreadArgument = callbackCallExpression.arguments[0];
+        if (spreadArgument?.type !== "SpreadElement")
+            return undefined;
+        if (spreadArgument.argument.type !== "Identifier")
+            return undefined;
+        return spreadArgument.argument.name;
+    }
+    if (callee.type !== "MemberExpression" ||
+        callee.computed ||
+        callee.object.type !== "Identifier" ||
+        callee.object.name !== outerParameterName ||
+        callee.property.type !== "Identifier") {
+        return undefined;
+    }
+    if (callee.property.name === "apply") {
+        if (callbackCallExpression.arguments.length !== 2)
+            return undefined;
+        const spreadArgument = callbackCallExpression.arguments[1];
+        if (spreadArgument?.type !== "Identifier")
+            return undefined;
+        return spreadArgument.name;
+    }
+    if (callee.property.name === "call") {
+        if (callbackCallExpression.arguments.length !== 2)
+            return undefined;
+        const spreadArgument = callbackCallExpression.arguments[1];
+        if (spreadArgument?.type !== "SpreadElement")
+            return undefined;
+        if (spreadArgument.argument.type !== "Identifier")
+            return undefined;
+        return spreadArgument.argument.name;
+    }
+    return undefined;
+};

package/dist/transforms-by-id/rename-asap-wrappers/has-exactly-one-lexical-return-statement.d.ts

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

package/dist/transforms-by-id/rename-asap-wrappers/has-exactly-one-lexical-return-statement.js

@@ -0,0 +1,48 @@
+import { VISITOR_KEYS } from "@babel/types";
+const FUNCTION_NODE_TYPES = new Set([
+    "ArrowFunctionExpression",
+    "ClassMethod",
+    "ClassPrivateMethod",
+    "FunctionDeclaration",
+    "FunctionExpression",
+    "ObjectMethod",
+]);
+const isNode = (value) => Boolean(value &&
+    typeof value === "object" &&
+    "type" in value &&
+    typeof value.type === "string");
+export const hasExactlyOneLexicalReturnStatement = (block) => {
+    let returnStatementCount = 0;
+    const stack = [...block.body];
+    while (stack.length > 0) {
+        const node = stack.pop();
+        if (!node)
+            continue;
+        if (node.type === "ReturnStatement") {
+            returnStatementCount += 1;
+            if (returnStatementCount > 1)
+                return false;
+            continue;
+        }
+        if (FUNCTION_NODE_TYPES.has(node.type))
+            continue;
+        const visitorKeys = VISITOR_KEYS[node.type];
+        if (!visitorKeys)
+            continue;
+        for (const key of visitorKeys) {
+            const child = node[key];
+            if (Array.isArray(child)) {
+                for (const nestedChild of child) {
+                    if (isNode(nestedChild)) {
+                        stack.push(nestedChild);
+                    }
+                }
+                continue;
+            }
+            if (isNode(child)) {
+                stack.push(child);
+            }
+        }
+    }
+    return returnStatementCount === 1;
+};

package/dist/transforms-by-id/rename-asap-wrappers/manifest.json

@@ -2,10 +2,10 @@
     "notes": "Measured with baseline none: 0.00%. Added to recommended for readability.",
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
-            "diffSizePercent": 100,
-            "evaluatedAt": "2026-02-10T06:12:05.881Z",
+            "diffSizePercent": 99.99811014098348,
+            "evaluatedAt": "2026-02-22T15:48:34.214Z",
             "changedLines": 10,
-            "durationSeconds": 69.52347904199999,
+            "durationSeconds": 31.124323875,
             "stableNames": 1358
         }
     },