miniread 1.115.3 → 1.115.4

package/dist/transforms/preset-stats.json

@@ -1,6 +1,6 @@
 {
     "recommended": {
-        "diffSizePercent": 25.304267301659294,
-        "notes": "Measured with baseline none: 25.30% of original diff."
+        "diffSizePercent": 25.62554333446725,
+        "notes": "Measured with baseline none: 25.63% of original diff."
     }
 }

package/dist/transforms-by-id/rename-command-result-variables/manifest.json

@@ -1,10 +1,10 @@
 {
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
-            "diffSizePercent": 100,
-            "evaluatedAt": "2026-02-14T12:53:18.669Z",
-            "changedLines": 338,
-            "durationSeconds": 38.783343792,
+            "diffSizePercent": 99.99055070491741,
+            "evaluatedAt": "2026-02-21T07:41:21.454Z",
+            "changedLines": 494,
+            "durationSeconds": 38.767131458,
             "stableNames": 1359
         }
     },

package/dist/transforms-by-id/rename-command-result-variables/rename-command-result-variables-transform.js

@@ -5,6 +5,16 @@ 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 = "commandResult";
+const isAwaitedCallResultBinding = (binding) => {
+    if (!binding.path.isVariableDeclarator())
+        return false;
+    const init = binding.path.node.init;
+    if (!init)
+        return false;
+    if (init.type !== "AwaitExpression")
+        return false;
+    return init.argument.type === "CallExpression";
+};
 const isCommandResultProperty = (path) => {
     const memberExpressionPath = path.parentPath;
     if (!memberExpressionPath.isMemberExpression())
@@ -38,7 +48,11 @@ const hasCommandResultPattern = (binding) => {
             hasOutputProperty = true;
         }
     }
-    return hasCodeProperty && hasOutputProperty;
+    if (!hasOutputProperty)
+        return false;
+    if (hasCodeProperty)
+        return true;
+    return isAwaitedCallResultBinding(binding);
 };
 export const renameCommandResultVariablesTransform = {
     id: "rename-command-result-variables",

package/dist/transforms-by-id/rename-error-first-callback-parameters/manifest.json

@@ -1,14 +1,14 @@
 {
-    "recommended": true,
-    "recommendedOrder": 100,
     "notes": "Measured with baseline none: diff size remains 100.00% of baseline for this evaluation set. This transform remains recommended because it targets no-else error-first guards and is complementary to rename-error-first-callback-parameters-v2.",
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
             "diffSizePercent": 100,
-            "evaluatedAt": "2026-02-07T21:24:52.681Z",
-            "changedLines": 416,
-            "durationSeconds": 202.892315483,
+            "evaluatedAt": "2026-02-21T06:37:23.328Z",
+            "changedLines": 428,
+            "durationSeconds": 142.79656364099998,
             "stableNames": 1360
         }
-    }
+    },
+    "recommended": true,
+    "recommendedOrder": 100
 }

package/dist/transforms-by-id/rename-error-first-callback-parameters/rename-error-first-callback-parameters-transform.js

@@ -46,7 +46,9 @@ const matchesErrorFirstGuard = (path) => {
         return undefined;
     if (firstBinding.kind !== "param")
         return undefined;
-    if (firstBinding.referencePaths.length !== 2)
+    if (firstBinding.constantViolations.length > 0)
+        return undefined;
+    if (firstBinding.referencePaths.length < 2)
         return undefined;
     const ifStatement = getErrorFirstIfStatement(path);
     if (!ifStatement)

package/dist/transforms-by-id/rename-http-method-parameters/manifest.json

@@ -1,13 +1,13 @@
 {
-    "recommended": true,
-    "recommendedOrder": 50,
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
             "diffSizePercent": 100,
-            "evaluatedAt": "2026-02-07T21:16:51.038Z",
-            "changedLines": 0,
-            "durationSeconds": 192.863831332,
-            "stableNames": 1357
+            "evaluatedAt": "2026-02-21T09:21:11.297Z",
+            "changedLines": 16,
+            "durationSeconds": 28.464535625,
+            "stableNames": 1358
         }
-    }
+    },
+    "recommended": true,
+    "recommendedOrder": 50
 }

package/dist/transforms-by-id/rename-http-method-parameters/rename-http-method-parameters-transform.js

@@ -1,7 +1,7 @@
 import { createRequire } from "node:module";
 import { RenameGroup, isStableRenamed } from "../../core/stable-naming.js";
 import { getFilesToProcess, } from "../../core/types.js";
-import { hasDynamicNameLookup } from "../../transforms/has-dynamic-name-lookup.js";
+import { hasDynamicNameLookup } from "../stabilize-nested-bindings/has-dynamic-name-lookup.js";
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 const traverse = require("@babel/traverse").default;
@@ -37,8 +37,6 @@ export const renameHttpMethodParametersTransform = {
         let nodesVisited = 0;
         let transformationsApplied = 0;
         for (const fileInfo of getFilesToProcess(context)) {
-            if (hasDynamicNameLookup(fileInfo.ast))
-                continue;
             const group = new RenameGroup();
             traverse(fileInfo.ast, {
                 CallExpression(path) {
@@ -70,6 +68,8 @@ export const renameHttpMethodParametersTransform = {
                     if (!callbackPath.isFunctionExpression() &&
                         !callbackPath.isArrowFunctionExpression())
                         return;
+                    if (hasDynamicNameLookup(callbackPath))
+                        return;
                     const parameterPaths = callbackPath.get("params");
                     if (!Array.isArray(parameterPaths))
                         return;

package/dist/transforms-by-id/rename-object-keys-iterator-variables/manifest.json

@@ -1,10 +1,10 @@
 {
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
-            "diffSizePercent": 100,
-            "evaluatedAt": "2026-02-12T13:18:42.927Z",
-            "changedLines": 1240,
-            "durationSeconds": 37.765023916,
+            "diffSizePercent": 99.99811014098348,
+            "evaluatedAt": "2026-02-21T09:45:41.024Z",
+            "changedLines": 1814,
+            "durationSeconds": 43.250947458999995,
             "stableNames": 1359
         }
     },

package/dist/transforms-by-id/rename-object-keys-iterator-variables/rename-object-keys-iterator-variables-transform.js

@@ -73,8 +73,10 @@ const renameIteratorBinding = (path, identifier, group, options) => {
     const binding = path.scope.getBinding(currentName);
     if (!binding)
         return;
-    if (!binding.constant)
+    if (binding.kind === "var" &&
+        [...binding.referencePaths, ...binding.constantViolations].some((usagePath) => !usagePath.isDescendant(path))) {
         return;
+    }
     group.add({
         scope: binding.scope,
         currentName,

package/dist/transforms-by-id/rename-return-object-bindings/collect-return-object-binding-candidates.js

@@ -13,6 +13,19 @@ const getPropertyName = (key) => {
     }
     return undefined;
 };
+const getReturnObjectExpression = (argument) => {
+    if (!argument)
+        return undefined;
+    if (argument.type === "ObjectExpression")
+        return argument;
+    if (argument.type !== "SequenceExpression")
+        return undefined;
+    const lastExpression = argument.expressions.at(-1);
+    if (lastExpression?.type !== "ObjectExpression") {
+        return undefined;
+    }
+    return lastExpression;
+};
 const collectCandidatesForObjectExpression = (options) => {
     const { objectExpression, scope, isScript, exportedNames, candidates } = options;
     for (const property of objectExpression.properties) {
@@ -68,11 +81,11 @@ export const collectReturnObjectBindingCandidates = (options) => {
     traverse(ast, {
         ReturnStatement(path) {
             nodesVisited++;
-            const argument = path.node.argument;
-            if (argument?.type !== "ObjectExpression")
+            const objectExpression = getReturnObjectExpression(path.node.argument);
+            if (!objectExpression)
                 return;
             collectCandidatesForObjectExpression({
-                objectExpression: argument,
+                objectExpression,
                 scope: path.scope,
                 isScript,
                 exportedNames,

package/dist/transforms-by-id/rename-uint8array-concat-variables/ast-helpers.d.ts

@@ -8,7 +8,7 @@ export declare const getBodyStatements: (bodyPath: NodePath<BlockStatement> | No
 export declare const getZeroInitializedVariable: (path: NodePath<Statement>) => ZeroInitMatch | undefined;
 export declare const getUint8ArrayInitializer: (path: NodePath<Statement>, totalLengthName: string) => ZeroInitMatch | undefined;
 export declare const getLoopVariable: (path: NodePath<ForOfStatement>) => NodePath<Identifier> | undefined;
-export declare const getArrayIdentifier: (expression: Expression) => string | undefined;
+export declare const getArrayExpression: (expression: Expression) => Expression;
 export declare const isPlusEqualsLength: (expression: Expression, targetName: string, loopVariableName: string) => boolean;
 export declare const isSetCall: (expression: Expression, outputName: string, loopVariableName: string, offsetName: string) => boolean;
 export {};

package/dist/transforms-by-id/rename-uint8array-concat-variables/ast-helpers.js

@@ -61,11 +61,7 @@ export const getLoopVariable = (path) => {
         return undefined;
     return idPath;
 };
-export const getArrayIdentifier = (expression) => {
-    if (!t.isIdentifier(expression))
-        return undefined;
-    return expression.name;
-};
+export const getArrayExpression = (expression) => expression;
 const isLengthAccess = (expression, objectName) => {
     if (!t.isMemberExpression(expression))
         return false;

package/dist/transforms-by-id/rename-uint8array-concat-variables/find-loop-copy-match.d.ts

@@ -0,0 +1,13 @@
+import type { Binding, NodePath, Scope } from "@babel/traverse";
+import type { ForOfStatement } from "@babel/types";
+export type LoopCopyMatch = {
+    outputBinding: Binding;
+    outputName: string;
+    offsetName: string;
+    offsetScope: Scope;
+    loopVariableName: string;
+    loopVarScope: Scope;
+    arrayName: string;
+    arrayScope: Scope | undefined;
+};
+export declare const findLoopCopyMatch: (loopPath: NodePath<ForOfStatement>) => LoopCopyMatch | undefined;

package/dist/transforms-by-id/rename-uint8array-concat-variables/find-loop-copy-match.js

@@ -0,0 +1,68 @@
+import * as t from "@babel/types";
+import { getLoopSetAndOffsetExpressions } from "./get-loop-set-and-offset-expressions.js";
+import { isPlusEqualsLengthOrByteLength } from "./is-plus-equals-length-or-bytelength.js";
+import { isSetMemberExpression } from "./is-set-member-expression.js";
+export const findLoopCopyMatch = (loopPath) => {
+    const leftPath = loopPath.get("left");
+    if (!leftPath.isVariableDeclaration())
+        return undefined;
+    if (leftPath.node.declarations.length !== 1)
+        return undefined;
+    const loopVariablePath = loopPath.get("left.declarations.0.id");
+    if (!loopVariablePath.isIdentifier())
+        return undefined;
+    const loopVariableName = loopVariablePath.node.name;
+    const bodyPath = loopPath.get("body");
+    const bodyStatements = bodyPath.isBlockStatement()
+        ? bodyPath.get("body")
+        : [bodyPath];
+    const setAndOffsetExpressions = getLoopSetAndOffsetExpressions(bodyStatements);
+    if (!setAndOffsetExpressions)
+        return undefined;
+    const [setExpression, offsetExpression] = setAndOffsetExpressions;
+    if (!t.isCallExpression(setExpression))
+        return undefined;
+    if (!t.isMemberExpression(setExpression.callee))
+        return undefined;
+    if (!t.isIdentifier(setExpression.callee.object))
+        return undefined;
+    if (!isSetMemberExpression(setExpression.callee))
+        return undefined;
+    if (setExpression.arguments.length !== 2)
+        return undefined;
+    const [valueArgument, offsetArgument] = setExpression.arguments;
+    if (!valueArgument || !offsetArgument)
+        return undefined;
+    if (!t.isIdentifier(valueArgument, { name: loopVariableName }))
+        return undefined;
+    if (!t.isIdentifier(offsetArgument))
+        return undefined;
+    const outputName = setExpression.callee.object.name;
+    const offsetName = offsetArgument.name;
+    if (!isPlusEqualsLengthOrByteLength(offsetExpression, offsetName, loopVariableName)) {
+        return undefined;
+    }
+    const outputBinding = loopPath.scope.getBinding(outputName);
+    if (!outputBinding)
+        return undefined;
+    const offsetBinding = loopPath.scope.getBinding(offsetName);
+    if (!offsetBinding)
+        return undefined;
+    const arrayName = t.isIdentifier(loopPath.node.right)
+        ? loopPath.node.right.name
+        : "";
+    const arrayBinding = arrayName
+        ? loopPath.scope.getBinding(arrayName)
+        : undefined;
+    const arrayScope = arrayBinding?.kind === "param" ? arrayBinding.scope : undefined;
+    return {
+        outputBinding,
+        outputName,
+        offsetName,
+        offsetScope: offsetBinding.scope,
+        loopVariableName,
+        loopVarScope: loopVariablePath.scope,
+        arrayName,
+        arrayScope,
+    };
+};

package/dist/transforms-by-id/rename-uint8array-concat-variables/find-uint8array-concat-match.js

@@ -44,17 +44,23 @@ const findMatchesInStatementList = (functionPath, statementPaths) => {
         const secondLoopMatch = getForOfSet(secondLoopStatement, outputMatch.name, offsetMatch.name);
         if (!secondLoopMatch)
             continue;
-        if (firstLoopMatch.arrayName !== secondLoopMatch.arrayName)
+        if (!t.isNodesEquivalent(firstLoopMatch.arrayExpression, secondLoopMatch.arrayExpression)) {
             continue;
+        }
         const returnName = getReturnName(returnStatement);
         if (!returnName)
             continue;
         if (returnName !== outputMatch.name)
             continue;
-        const arrayBinding = functionPath.scope.getBinding(firstLoopMatch.arrayName);
+        const arrayName = t.isIdentifier(firstLoopMatch.arrayExpression)
+            ? firstLoopMatch.arrayExpression.name
+            : "";
+        const arrayBinding = arrayName
+            ? functionPath.scope.getBinding(arrayName)
+            : undefined;
         const arrayScope = arrayBinding?.kind === "param" ? arrayBinding.scope : undefined;
         matches.push({
-            arrayName: firstLoopMatch.arrayName,
+            arrayName,
             arrayScope,
             totalLengthName: totalLengthMatch.name,
             totalLengthScope: totalLengthMatch.scope,

package/dist/transforms-by-id/rename-uint8array-concat-variables/find-uint8array-output-rename-matches.d.ts

@@ -0,0 +1,14 @@
+import type { NodePath, Scope } from "@babel/traverse";
+import type { Function } from "@babel/types";
+type Uint8ArrayOutputRenameMatch = {
+    outputScope: Scope;
+    outputName: string;
+    offsetName: string;
+    offsetScope: Scope;
+    loopVariableName: string;
+    loopVarScope: Scope;
+    arrayName: string;
+    arrayScope: Scope | undefined;
+};
+export declare const findUint8ArrayOutputRenameMatches: (functionPath: NodePath<Function>) => Uint8ArrayOutputRenameMatch[];
+export {};

package/dist/transforms-by-id/rename-uint8array-concat-variables/find-uint8array-output-rename-matches.js

@@ -0,0 +1,60 @@
+import * as t from "@babel/types";
+import { findLoopCopyMatch, } from "./find-loop-copy-match.js";
+export const findUint8ArrayOutputRenameMatches = (functionPath) => {
+    const uint8ArrayBindings = new Set();
+    const returnedBindings = new Set();
+    const loopMatches = [];
+    functionPath.traverse({
+        Function(innerPath) {
+            innerPath.skip();
+        },
+        VariableDeclarator(variablePath) {
+            const idPath = variablePath.get("id");
+            if (!idPath.isIdentifier())
+                return;
+            const initPath = variablePath.get("init");
+            if (!initPath.isNewExpression())
+                return;
+            if (!t.isIdentifier(initPath.node.callee, { name: "Uint8Array" })) {
+                return;
+            }
+            const binding = variablePath.scope.getBinding(idPath.node.name);
+            if (!binding)
+                return;
+            uint8ArrayBindings.add(binding);
+        },
+        ReturnStatement(returnPath) {
+            const argumentPath = returnPath.get("argument");
+            if (!argumentPath.isIdentifier())
+                return;
+            const binding = returnPath.scope.getBinding(argumentPath.node.name);
+            if (!binding)
+                return;
+            returnedBindings.add(binding);
+        },
+        ForOfStatement(loopPath) {
+            const loopMatch = findLoopCopyMatch(loopPath);
+            if (!loopMatch)
+                return;
+            loopMatches.push(loopMatch);
+        },
+    });
+    const outputMatches = [];
+    for (const match of loopMatches) {
+        if (!uint8ArrayBindings.has(match.outputBinding))
+            continue;
+        if (!returnedBindings.has(match.outputBinding))
+            continue;
+        outputMatches.push({
+            outputScope: match.outputBinding.scope,
+            outputName: match.outputName,
+            offsetScope: match.offsetScope,
+            offsetName: match.offsetName,
+            loopVarScope: match.loopVarScope,
+            loopVariableName: match.loopVariableName,
+            arrayName: match.arrayName,
+            arrayScope: match.arrayScope,
+        });
+    }
+    return outputMatches;
+};

package/dist/transforms-by-id/rename-uint8array-concat-variables/get-loop-set-and-offset-expressions.d.ts

@@ -0,0 +1,3 @@
+import type { NodePath } from "@babel/traverse";
+import type { Expression, Statement } from "@babel/types";
+export declare const getLoopSetAndOffsetExpressions: (statements: NodePath<Statement>[]) => [setExpression: Expression, offsetExpression: Expression] | undefined;

package/dist/transforms-by-id/rename-uint8array-concat-variables/get-loop-set-and-offset-expressions.js

@@ -0,0 +1,28 @@
+import * as t from "@babel/types";
+export const getLoopSetAndOffsetExpressions = (statements) => {
+    if (statements.length === 2) {
+        const [setStatement, offsetStatement] = statements;
+        if (!setStatement || !offsetStatement)
+            return undefined;
+        if (!setStatement.isExpressionStatement())
+            return undefined;
+        if (!offsetStatement.isExpressionStatement())
+            return undefined;
+        return [setStatement.node.expression, offsetStatement.node.expression];
+    }
+    if (statements.length !== 1)
+        return undefined;
+    const [singleStatement] = statements;
+    if (!singleStatement)
+        return undefined;
+    if (!singleStatement.isExpressionStatement())
+        return undefined;
+    if (!t.isSequenceExpression(singleStatement.node.expression))
+        return undefined;
+    if (singleStatement.node.expression.expressions.length !== 2)
+        return undefined;
+    const [setExpression, offsetExpression] = singleStatement.node.expression.expressions;
+    if (!setExpression || !offsetExpression)
+        return undefined;
+    return [setExpression, offsetExpression];
+};

package/dist/transforms-by-id/rename-uint8array-concat-variables/has-local-dynamic-name-lookup.d.ts

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

package/dist/transforms-by-id/rename-uint8array-concat-variables/has-local-dynamic-name-lookup.js

@@ -0,0 +1,38 @@
+import * as t from "@babel/types";
+import { isEvalLikeCallCallee } from "../../transforms/dynamic-name-lookup/eval-like-call-detection.js";
+export const hasLocalDynamicNameLookup = (functionPath) => {
+    let found = false;
+    functionPath.traverse({
+        WithStatement(path) {
+            found = true;
+            path.stop();
+        },
+        ReferencedIdentifier(path) {
+            if (found)
+                return;
+            if (!t.isIdentifier(path.node, { name: "eval" }))
+                return;
+            if (path.scope.getBinding("eval"))
+                return;
+            found = true;
+            path.stop();
+        },
+        CallExpression(path) {
+            if (found)
+                return;
+            if (!isEvalLikeCallCallee(path.node.callee, path.scope))
+                return;
+            found = true;
+            path.stop();
+        },
+        OptionalCallExpression(path) {
+            if (found)
+                return;
+            if (!isEvalLikeCallCallee(path.node.callee, path.scope))
+                return;
+            found = true;
+            path.stop();
+        },
+    });
+    return found;
+};

package/dist/transforms-by-id/rename-uint8array-concat-variables/is-plus-equals-length-or-bytelength.d.ts

@@ -0,0 +1,2 @@
+import type { Expression } from "@babel/types";
+export declare const isPlusEqualsLengthOrByteLength: (expression: Expression, targetName: string, loopVariableName: string) => boolean;

package/dist/transforms-by-id/rename-uint8array-concat-variables/is-plus-equals-length-or-bytelength.js

@@ -0,0 +1,25 @@
+import * as t from "@babel/types";
+const isLengthOrByteLengthAccess = (expression, objectName) => {
+    if (!t.isMemberExpression(expression))
+        return false;
+    if (!t.isIdentifier(expression.object, { name: objectName }))
+        return false;
+    if (!expression.computed && t.isIdentifier(expression.property)) {
+        return (expression.property.name === "length" ||
+            expression.property.name === "byteLength");
+    }
+    if (expression.computed && t.isStringLiteral(expression.property)) {
+        return (expression.property.value === "length" ||
+            expression.property.value === "byteLength");
+    }
+    return false;
+};
+export const isPlusEqualsLengthOrByteLength = (expression, targetName, loopVariableName) => {
+    if (!t.isAssignmentExpression(expression))
+        return false;
+    if (expression.operator !== "+=")
+        return false;
+    if (!t.isIdentifier(expression.left, { name: targetName }))
+        return false;
+    return isLengthOrByteLengthAccess(expression.right, loopVariableName);
+};

package/dist/transforms-by-id/rename-uint8array-concat-variables/is-set-member-expression.d.ts

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

package/dist/transforms-by-id/rename-uint8array-concat-variables/is-set-member-expression.js

@@ -0,0 +1,10 @@
+import * as t from "@babel/types";
+export const isSetMemberExpression = (callee) => {
+    if (!callee.computed && t.isIdentifier(callee.property, { name: "set" })) {
+        return true;
+    }
+    if (callee.computed && t.isStringLiteral(callee.property, { value: "set" })) {
+        return true;
+    }
+    return false;
+};

package/dist/transforms-by-id/rename-uint8array-concat-variables/loop-matches.d.ts

@@ -1,12 +1,12 @@
 import type { NodePath, Scope } from "@babel/traverse";
-import type { Statement } from "@babel/types";
+import type { Expression, Statement } from "@babel/types";
 type ForOfLengthSumMatch = {
-    arrayName: string;
+    arrayExpression: Expression;
     loopVariableName: string;
     loopVarScope: Scope;
 };
 type ForOfSetMatch = {
-    arrayName: string;
+    arrayExpression: Expression;
     loopVariableName: string;
     loopVarScope: Scope;
 };

package/dist/transforms-by-id/rename-uint8array-concat-variables/loop-matches.js

@@ -1,13 +1,39 @@
-import { getArrayIdentifier, getBodyStatements, getLoopVariable, isPlusEqualsLength, isSetCall, } from "./ast-helpers.js";
+import * as t from "@babel/types";
+import { getArrayExpression, getBodyStatements, getLoopVariable, isPlusEqualsLength, isSetCall, } from "./ast-helpers.js";
+const getSetAndOffsetExpressions = (statements) => {
+    if (statements.length === 2) {
+        const [setStatement, offsetStatement] = statements;
+        if (!setStatement || !offsetStatement)
+            return undefined;
+        if (!setStatement.isExpressionStatement())
+            return undefined;
+        if (!offsetStatement.isExpressionStatement())
+            return undefined;
+        return [setStatement.node.expression, offsetStatement.node.expression];
+    }
+    if (statements.length !== 1)
+        return undefined;
+    const [singleStatement] = statements;
+    if (!singleStatement)
+        return undefined;
+    if (!singleStatement.isExpressionStatement())
+        return undefined;
+    if (!t.isSequenceExpression(singleStatement.node.expression))
+        return undefined;
+    if (singleStatement.node.expression.expressions.length !== 2)
+        return undefined;
+    const [setExpression, offsetExpression] = singleStatement.node.expression.expressions;
+    if (!setExpression || !offsetExpression)
+        return undefined;
+    return [setExpression, offsetExpression];
+};
 export const getForOfLengthSum = (path, totalLengthName) => {
     if (!path.isForOfStatement())
         return undefined;
     const loopVariablePath = getLoopVariable(path);
     if (!loopVariablePath)
         return undefined;
-    const arrayName = getArrayIdentifier(path.node.right);
-    if (!arrayName)
-        return undefined;
+    const arrayExpression = getArrayExpression(path.node.right);
     const statements = getBodyStatements(path.get("body"));
     if (statements.length !== 1)
         return undefined;
@@ -21,7 +47,7 @@ export const getForOfLengthSum = (path, totalLengthName) => {
         return undefined;
     }
     return {
-        arrayName,
+        arrayExpression,
         loopVariableName: loopVariablePath.node.name,
         loopVarScope: loopVariablePath.scope,
     };
@@ -32,29 +58,20 @@ export const getForOfSet = (path, outputName, offsetName) => {
     const loopVariablePath = getLoopVariable(path);
     if (!loopVariablePath)
         return undefined;
-    const arrayName = getArrayIdentifier(path.node.right);
-    if (!arrayName)
-        return undefined;
+    const arrayExpression = getArrayExpression(path.node.right);
     const statements = getBodyStatements(path.get("body"));
-    if (statements.length !== 2)
-        return undefined;
-    const [setStatement, offsetStatement] = statements;
-    if (!setStatement || !offsetStatement)
-        return undefined;
-    if (!setStatement.isExpressionStatement())
-        return undefined;
-    if (!offsetStatement.isExpressionStatement())
+    const setAndOffsetExpressions = getSetAndOffsetExpressions(statements);
+    if (!setAndOffsetExpressions)
         return undefined;
-    const setExpression = setStatement.node.expression;
+    const [setExpression, offsetExpression] = setAndOffsetExpressions;
     if (!isSetCall(setExpression, outputName, loopVariablePath.node.name, offsetName)) {
         return undefined;
     }
-    const offsetExpression = offsetStatement.node.expression;
     if (!isPlusEqualsLength(offsetExpression, offsetName, loopVariablePath.node.name)) {
         return undefined;
     }
     return {
-        arrayName,
+        arrayExpression,
         loopVariableName: loopVariablePath.node.name,
         loopVarScope: loopVariablePath.scope,
     };

package/dist/transforms-by-id/rename-uint8array-concat-variables/manifest.json

@@ -1,14 +1,14 @@
 {
-    "recommended": true,
-    "recommendedOrder": 100,
     "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-07T21:19:46.535Z",
-            "changedLines": 0,
-            "durationSeconds": 223.248709286,
-            "stableNames": 1357
+            "evaluatedAt": "2026-02-21T07:21:13.555Z",
+            "changedLines": 88,
+            "durationSeconds": 31.42075075,
+            "stableNames": 1361
         }
-    }
+    },
+    "recommended": true,
+    "recommendedOrder": 100
 }

package/dist/transforms-by-id/rename-uint8array-concat-variables/rename-uint8array-concat-variables-transform.js

@@ -2,6 +2,8 @@ import { createRequire } from "node:module";
 import { RenameGroup } from "../../core/stable-naming.js";
 import { getFilesToProcess, } from "../../core/types.js";
 import { findUint8ArrayConcatMatches } from "./find-uint8array-concat-match.js";
+import { findUint8ArrayOutputRenameMatches } from "./find-uint8array-output-rename-matches.js";
+import { hasLocalDynamicNameLookup } from "./has-local-dynamic-name-lookup.js";
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 const traverse = require("@babel/traverse").default;
@@ -30,9 +32,33 @@ export const renameUint8arrayConcatVariablesTransform = {
             traverse(fileInfo.ast, {
                 Function(path) {
                     nodesVisited++;
-                    const matches = findUint8ArrayConcatMatches(path);
-                    if (matches.length === 0)
+                    if (hasLocalDynamicNameLookup(path))
                         return;
+                    for (const outputMatch of findUint8ArrayOutputRenameMatches(path)) {
+                        if (outputMatch.arrayScope) {
+                            addRenameOnce(renamedVariablesByScope, group, {
+                                scope: outputMatch.arrayScope,
+                                currentName: outputMatch.arrayName,
+                                baseName: "chunks",
+                            });
+                        }
+                        addRenameOnce(renamedVariablesByScope, group, {
+                            scope: outputMatch.outputScope,
+                            currentName: outputMatch.outputName,
+                            baseName: "bytes",
+                        });
+                        addRenameOnce(renamedVariablesByScope, group, {
+                            scope: outputMatch.offsetScope,
+                            currentName: outputMatch.offsetName,
+                            baseName: "byteOffset",
+                        });
+                        addRenameOnce(renamedVariablesByScope, group, {
+                            scope: outputMatch.loopVarScope,
+                            currentName: outputMatch.loopVariableName,
+                            baseName: "chunk",
+                        });
+                    }
+                    const matches = findUint8ArrayConcatMatches(path);
                     for (const match of matches) {
                         if (match.arrayScope) {
                             addRenameOnce(renamedVariablesByScope, group, {

package/dist/transforms-by-id/stabilize-deferred-stable-rhs/manifest.json

@@ -1,12 +1,12 @@
 {
-    "notes": "Stabilizes deferred top-level vars whose RHS contains only stable identifiers (globals or $h_/$f_/$v_ prefixed names). Derives names by hashing the RHS code. Complements stabilize-deferred-top-level-bindings by handling multi-var functions.",
+    "notes": "Stabilizes deferred top-level var/let bindings whose RHS contains only stable identifiers (globals or $h_/$f_/$v_ prefixed names). Derives names by hashing the RHS code. Complements stabilize-deferred-top-level-bindings by handling multi-var functions.",
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
-            "diffSizePercent": 98.27455871791965,
-            "evaluatedAt": "2026-02-18T06:53:13.858Z",
-            "changedLines": 6008,
-            "durationSeconds": 43.110313000000005,
-            "stableNames": 1996
+            "diffSizePercent": 97.66602411460104,
+            "evaluatedAt": "2026-02-21T09:23:30.126Z",
+            "changedLines": 9309,
+            "durationSeconds": 44.433428834,
+            "stableNames": 2231
         }
     },
     "recommended": true,

package/dist/transforms-by-id/stabilize-deferred-stable-rhs/stabilize-deferred-stable-rhs-transform.js

@@ -14,9 +14,25 @@ const traverse = require("@babel/traverse").default;
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 const generate = require("@babel/generator").default;
 const hashCode = (code) => createHash("sha256").update(code).digest("hex").slice(0, 16);
+const hasNameIndependentShadowingRisk = (bindingScope, bindingName) => {
+    const binding = bindingScope.getBinding(bindingName);
+    if (!binding)
+        return true;
+    const identifierPaths = [
+        ...binding.referencePaths,
+        ...binding.constantViolations,
+    ];
+    return identifierPaths.some((identifierPath) => {
+        if (identifierPath.scope === bindingScope)
+            return false;
+        return (identifierPath.findParent((path) => {
+            return t.isWithStatement(path.node);
+        }) !== null);
+    });
+};
 export const stabilizeDeferredStableRhsTransform = {
     id: "stabilize-deferred-stable-rhs",
-    description: "Renames deferred top-level vars whose RHS contains only stable identifiers " +
+    description: "Renames deferred top-level var/let bindings whose RHS contains only stable identifiers " +
         "(globals or $h_/$f_/$v_ prefixed). Derives stable names by hashing the RHS code. " +
         "Complements stabilize-deferred-top-level-bindings by handling multi-var functions.",
     scope: "file",
@@ -37,14 +53,14 @@ export const stabilizeDeferredStableRhsTransform = {
                 continue;
             const fileProgramScope = programScope;
             const programScopeBindings = new Set(Object.keys(fileProgramScope.bindings));
-            // Step 1: Find all uninitialized top-level vars that aren't already stable
+            // Step 1: Find all uninitialized top-level var/let bindings that are not already stable
             const uninitializedVariables = new Set();
             traverse(fileInfo.ast, {
                 VariableDeclaration(path) {
                     nodesVisited++;
                     if (path.parent.type !== "Program")
                         return;
-                    if (path.node.kind !== "var")
+                    if (path.node.kind !== "var" && path.node.kind !== "let")
                         return;
                     for (const declaration of path.node.declarations) {
                         if (!declaration.init &&
@@ -55,7 +71,7 @@ export const stabilizeDeferredStableRhsTransform = {
                     }
                 },
             });
-            // Step 2: Find assignments to those vars inside functions.
+            // Step 2: Find assignments to those bindings inside functions.
             // Exclude shadowed locals by requiring the assignment target to resolve
             // to the program-scope binding for that name.
             const assignments = [];
@@ -72,9 +88,6 @@ export const stabilizeDeferredStableRhsTransform = {
                         return;
                     if (path.scope.getBinding(variableName) !== programBinding)
                         return;
-                    const functionPath = path.findParent((p) => p.isFunction());
-                    if (!functionPath)
-                        return;
                     // Check stability and capture RHS code NOW, before any renames happen.
                     // This prevents order-dependent cascading where renaming one var
                     // makes another var's RHS appear stable.
@@ -82,7 +95,6 @@ export const stabilizeDeferredStableRhsTransform = {
                     const isStable = hasAllStableReferences(rhsNode, programScopeBindings);
                     assignments.push({
                         variableName,
-                        rhsNode,
                         rhsCode: isStable
                             ? generate(rhsNode, { concise: true }).code
                             : undefined,
@@ -90,7 +102,7 @@ export const stabilizeDeferredStableRhsTransform = {
                 },
             });
             // Step 3: Apply renames for assignments with all-stable RHS.
-            // Deduplicate by variable name — if a var has multiple assignments,
+            // Deduplicate by variable name — if a binding has multiple assignments,
             // use only the first (order is AST traversal order).
             // Track used target names to prevent collisions: two vars with identical
             // RHS code produce the same hash, and renameBindingInPlace does not update
@@ -104,13 +116,19 @@ export const stabilizeDeferredStableRhsTransform = {
                 if (seen.has(variableName))
                     continue;
                 seen.add(variableName);
-                const newName = `$v_${hashCode(rhsCode)}`;
-                if (usedNewNames.has(newName))
-                    continue;
-                if (!canRenameBindingSafely(programScope, variableName, newName))
+                if (hasNameIndependentShadowingRisk(programScope, variableName)) {
                     continue;
-                if (renameBindingInPlace(programScope, variableName, newName)) {
-                    usedNewNames.add(newName);
+                }
+                const baseName = `$v_${hashCode(rhsCode)}`;
+                let candidateName = baseName;
+                let suffix = 2;
+                while (usedNewNames.has(candidateName) ||
+                    !canRenameBindingSafely(programScope, variableName, candidateName)) {
+                    candidateName = `${baseName}_${suffix}`;
+                    suffix++;
+                }
+                if (renameBindingInPlace(programScope, variableName, candidateName)) {
+                    usedNewNames.add(candidateName);
                     fileTransformations++;
                 }
             }

package/dist/transforms-by-id/stabilize-nested-bindings/is-factory-callback.d.ts

@@ -1,6 +1,11 @@
+import type { NodePath } from "@babel/traverse";
 import type { ArrowFunctionExpression, FunctionExpression } from "@babel/types";
 /**
  * Checks if a function looks like a CommonJS factory callback.
- * Heuristic: 1-2 parameters with the first being an identifier (e.g., exports, module).
+ * Heuristic:
+ * - 1-2 parameters: preserve existing broad behavior (first parameter must be an identifier).
+ * - 3 parameters: preserve broad matching, but reject known middleware
+ *   handler signatures (req/res/next-like) that are outside this transform's
+ *   intended scope.
  */
-export declare const isFactoryCallback: (callback: FunctionExpression | ArrowFunctionExpression) => boolean;
+export declare const isFactoryCallback: (callbackPath: NodePath<FunctionExpression | ArrowFunctionExpression>) => boolean;

package/dist/transforms-by-id/stabilize-nested-bindings/is-factory-callback.js

@@ -1,11 +1,37 @@
 import * as t from "@babel/types";
+const MIDDLEWARE_PARAMETER_SIGNATURES = new Set([
+    "req|res|next",
+    "request|response|next",
+    "ctx|next|error",
+    "context|next|error",
+]);
+const normalizeParameterName = (name) => name.replace(/^[$_]+/u, "").toLowerCase();
+const isKnownMiddlewareSignature = (names) => MIDDLEWARE_PARAMETER_SIGNATURES.has(names.join("|"));
 /**
  * Checks if a function looks like a CommonJS factory callback.
- * Heuristic: 1-2 parameters with the first being an identifier (e.g., exports, module).
+ * Heuristic:
+ * - 1-2 parameters: preserve existing broad behavior (first parameter must be an identifier).
+ * - 3 parameters: preserve broad matching, but reject known middleware
+ *   handler signatures (req/res/next-like) that are outside this transform's
+ *   intended scope.
  */
-export const isFactoryCallback = (callback) => {
-    const parameters = callback.params;
-    if (parameters.length === 0 || parameters.length > 2)
+export const isFactoryCallback = (callbackPath) => {
+    const parameters = callbackPath.node.params;
+    if (parameters.length === 0 || parameters.length > 3)
         return false;
-    return t.isIdentifier(parameters[0]);
+    const firstParameter = parameters[0];
+    if (!t.isIdentifier(firstParameter))
+        return false;
+    if (parameters.length < 3)
+        return true;
+    const secondParameter = parameters[1];
+    const thirdParameter = parameters[2];
+    if (!t.isIdentifier(secondParameter) || !t.isIdentifier(thirdParameter))
+        return true;
+    const normalizedParameterNames = [
+        normalizeParameterName(firstParameter.name),
+        normalizeParameterName(secondParameter.name),
+        normalizeParameterName(thirdParameter.name),
+    ];
+    return !isKnownMiddlewareSignature(normalizedParameterNames);
 };

package/dist/transforms-by-id/stabilize-nested-bindings/manifest.json

@@ -2,11 +2,11 @@
     "notes": "Stabilizes local bindings inside CommonJS factory callbacks using content-hash naming ($f_<hash>). Must run AFTER stabilize-top-level-bindings. Combined with top-level stabilization, achieves 33.49% diff size (67% reduction from baseline).",
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
-            "diffSizePercent": 56.44536417583248,
-            "evaluatedAt": "2026-02-18T06:56:26.504Z",
-            "changedLines": 115147,
-            "durationSeconds": 85.89585675000001,
-            "stableNames": 13284
+            "diffSizePercent": 56.432135162716854,
+            "evaluatedAt": "2026-02-21T09:46:16.200Z",
+            "changedLines": 115623,
+            "durationSeconds": 81.049385083,
+            "stableNames": 13327
         }
     },
     "recommended": true,

package/dist/transforms-by-id/stabilize-nested-bindings/stabilize-nested-bindings-transform.js

@@ -19,14 +19,14 @@ const renameCallbackLocalBindings = (path) => {
     if (!t.isFunctionExpression(firstArgument) &&
         !t.isArrowFunctionExpression(firstArgument))
         return 0;
-    // Verify it looks like a callback shape this transform should process
-    if (!isFactoryCallback(firstArgument))
-        return 0;
     // Get the path to the function argument
     const functionArgumentPath = path.get("arguments.0");
     if (!functionArgumentPath.isFunctionExpression() &&
         !functionArgumentPath.isArrowFunctionExpression())
         return 0;
+    // Verify it looks like a callback shape this transform should process
+    if (!isFactoryCallback(functionArgumentPath))
+        return 0;
     // Skip renaming if callback contains dynamic name lookup (eval, with, etc.)
     if (hasDynamicNameLookup(functionArgumentPath))
         return 0;

package/package.json

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