miniread 1.115.0 → 1.115.1

package/dist/transforms/preset-stats.json

@@ -1,6 +1,6 @@
 {
     "recommended": {
-        "diffSizePercent": 25.50270249839362,
-        "notes": "Average test/baseline diff size ratio for the recommended preset with baseline set to none."
+        "diffSizePercent": 25.296707865593227,
+        "notes": "Measured with baseline none: 25.30% of original diff."
     }
 }

package/dist/transforms-by-id/rename-array-accumulator-variables/manifest.json

@@ -2,10 +2,10 @@
     "notes": "Renames variables initialized as empty arrays with .push()/.unshift() usage to stable/readable names.",
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
-            "diffSizePercent": 99.94708394753752,
-            "evaluatedAt": "2026-02-17T08:05:01.672Z",
-            "changedLines": 9338,
-            "durationSeconds": 41.067913833,
+            "diffSizePercent": 98.38606039989418,
+            "evaluatedAt": "2026-02-18T06:56:35.742Z",
+            "changedLines": 18428,
+            "durationSeconds": 52.968690957999996,
             "stableNames": 1360
         }
     },

package/dist/transforms-by-id/rename-array-accumulator-variables/rename-array-accumulator-variables-transform.js

@@ -5,42 +5,24 @@ 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 = "results";
-/**
- * Checks whether a binding reference is an accumulator mutation call on the variable.
- * Matches: `X.push(...)` or `X.unshift(...)` where X is the binding.
- */
-const isAccumulatorMutationReference = (referencePath) => {
-    const memberPath = referencePath.parentPath;
-    if (!memberPath?.isMemberExpression())
+const isArrayInitialization = (path) => {
+    const init = path.node.init;
+    if (!init)
         return false;
-    // Must be X.push/X.unshift (not X[push] or X["push"])
-    if (memberPath.node.computed)
+    if (init.type === "ArrayExpression")
+        return true;
+    if (init.type !== "NewExpression")
         return false;
-    if (memberPath.node.object !== referencePath.node)
+    if (init.callee.type !== "Identifier")
         return false;
-    const property = memberPath.node.property;
-    if (property.type !== "Identifier")
+    if (init.callee.name !== "Array")
         return false;
-    if (property.name !== "push" && property.name !== "unshift")
-        return false;
-    // The member expression must be called: X.push(...) / X.unshift(...)
-    const callPath = memberPath.parentPath;
-    if (!callPath.isCallExpression())
-        return false;
-    if (callPath.node.callee !== memberPath.node)
-        return false;
-    return true;
-};
-/**
- * Checks whether a binding has at least one array mutation call reference,
- * confirming the accumulator pattern.
- */
-const hasAtLeastOneAccumulatorMutation = (referencePaths) => {
-    return referencePaths.some((path) => isAccumulatorMutationReference(path));
+    // Only treat the global Array constructor as an array initializer.
+    return !path.scope.hasBinding("Array", true);
 };
 export const renameArrayAccumulatorVariablesTransform = {
     id: "rename-array-accumulator-variables",
-    description: "Renames variables initialized as empty arrays with .push()/.unshift() usage to $results/$results2/... or results/results2/...",
+    description: "Renames local variables initialized as arrays to $results/$results2/... or results/results2/...",
     scope: "file",
     parallelizable: true,
     transform(context) {
@@ -59,24 +41,13 @@ export const renameArrayAccumulatorVariablesTransform = {
                         return;
                     if (currentName === BASE_NAME)
                         return;
-                    // Must be initialized with an empty array literal: `let X = []`
-                    const init = path.node.init;
-                    if (init?.type !== "ArrayExpression")
-                        return;
-                    if (init.elements.length > 0)
+                    if (!isArrayInitialization(path))
                         return;
                     const binding = path.scope.getBinding(currentName);
                     if (!binding)
                         return;
-                    // Must not be reassigned (Babel treats `const x = []; x.push(1)` as constant)
-                    if (!binding.constant)
-                        return;
-                    // Must have at least one reference
                     if (binding.referencePaths.length === 0)
                         return;
-                    // Must have at least one array mutation call to confirm accumulator pattern
-                    if (!hasAtLeastOneAccumulatorMutation(binding.referencePaths))
-                        return;
                     group.add({
                         scope: path.scope,
                         currentName,

package/dist/transforms-by-id/rename-invalid-parameter-arguments/manifest.json

@@ -1,14 +1,14 @@
 {
-    "recommended": true,
-    "recommendedOrder": 100,
     "notes": "Added to recommended for readability of invalidParameterError call sites.",
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
-            "diffSizePercent": 100,
-            "evaluatedAt": "2026-02-07T21:13:39.357Z",
-            "changedLines": 0,
-            "durationSeconds": 191.643123151,
-            "stableNames": 1357
+            "diffSizePercent": 99.99811516350957,
+            "evaluatedAt": "2026-02-17T13:28:14.742Z",
+            "changedLines": 420,
+            "durationSeconds": 204.312632724,
+            "stableNames": 1379
         }
-    }
+    },
+    "recommended": true,
+    "recommendedOrder": 100
 }

package/dist/transforms-by-id/rename-invalid-parameter-arguments/rename-invalid-parameter-arguments-transform.js

@@ -33,15 +33,13 @@ const isInvalidParameterErrorCallee = (callee) => {
     }
     if (callee.type !== "MemberExpression")
         return false;
-    if (callee.object.type !== "Identifier")
-        return false;
-    if (callee.object.name !== "errors")
-        return false;
-    if (callee.computed)
-        return false;
-    if (callee.property.type !== "Identifier")
+    if (!callee.computed && callee.property.type === "Identifier") {
+        return callee.property.name === "invalidParameterError";
+    }
+    if (!callee.computed || callee.property.type !== "StringLiteral") {
         return false;
-    return callee.property.name === "invalidParameterError";
+    }
+    return callee.property.value === "invalidParameterError";
 };
 const getInvalidParameterRename = (path) => {
     if (!isInvalidParameterErrorCallee(path.node.callee))

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

@@ -1,14 +1,14 @@
 {
-    "recommended": true,
-    "recommendedOrder": 4,
     "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.",
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
-            "diffSizePercent": 100,
-            "evaluatedAt": "2026-02-07T21:26:44.102Z",
-            "changedLines": 0,
-            "durationSeconds": 213.569470717,
-            "stableNames": 1357
+            "diffSizePercent": 98.27455871791965,
+            "evaluatedAt": "2026-02-18T06:53:13.858Z",
+            "changedLines": 6008,
+            "durationSeconds": 43.110313000000005,
+            "stableNames": 1996
         }
-    }
+    },
+    "recommended": true,
+    "recommendedOrder": 4
 }

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

@@ -5,7 +5,7 @@ import * as t from "@babel/types";
 import { getFilesToProcess, } from "../../core/types.js";
 import { generateCode } from "../../core/generate-code.js";
 import { isHashBasedStableName } from "../../core/stable-naming.js";
-import { findEnclosingBindingName, renameBindingInPlace, } from "../stabilize-deferred-top-level-bindings/rename-helpers.js";
+import { renameBindingInPlace } from "../stabilize-deferred-top-level-bindings/rename-helpers.js";
 import { canRenameBindingSafely } from "../../transforms/shared/can-rename-binding-safely.js";
 import { hasAllStableReferences } from "./check-rhs-stability.js";
 const require = createRequire(import.meta.url);
@@ -35,7 +35,8 @@ export const stabilizeDeferredStableRhsTransform = {
             });
             if (!programScope)
                 continue;
-            const programScopeBindings = new Set(Object.keys(programScope.bindings));
+            const fileProgramScope = programScope;
+            const programScopeBindings = new Set(Object.keys(fileProgramScope.bindings));
             // Step 1: Find all uninitialized top-level vars that aren't already stable
             const uninitializedVariables = new Set();
             traverse(fileInfo.ast, {
@@ -54,7 +55,9 @@ export const stabilizeDeferredStableRhsTransform = {
                     }
                 },
             });
-            // Step 2: Find assignments inside stable-named functions
+            // Step 2: Find assignments to those vars inside functions.
+            // Exclude shadowed locals by requiring the assignment target to resolve
+            // to the program-scope binding for that name.
             const assignments = [];
             traverse(fileInfo.ast, {
                 AssignmentExpression(path) {
@@ -64,13 +67,14 @@ export const stabilizeDeferredStableRhsTransform = {
                     const variableName = path.node.left.name;
                     if (!uninitializedVariables.has(variableName))
                         return;
+                    const programBinding = fileProgramScope.getBinding(variableName);
+                    if (!programBinding)
+                        return;
+                    if (path.scope.getBinding(variableName) !== programBinding)
+                        return;
                     const functionPath = path.findParent((p) => p.isFunction());
                     if (!functionPath)
                         return;
-                    const enclosingFunctionName = findEnclosingBindingName(functionPath);
-                    if (!enclosingFunctionName ||
-                        !isHashBasedStableName(enclosingFunctionName))
-                        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.
@@ -79,7 +83,6 @@ export const stabilizeDeferredStableRhsTransform = {
                     assignments.push({
                         variableName,
                         rhsNode,
-                        enclosingFunctionName,
                         rhsCode: isStable
                             ? generate(rhsNode, { concise: true }).code
                             : undefined,

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

@@ -1,14 +1,14 @@
 {
-    "recommended": true,
-    "recommendedOrder": 2,
     "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": 100,
-            "evaluatedAt": "2026-02-07T21:15:58.445Z",
-            "changedLines": 0,
-            "durationSeconds": 207.29271774999998,
-            "stableNames": 1357
+            "diffSizePercent": 56.44536417583248,
+            "evaluatedAt": "2026-02-18T06:56:26.504Z",
+            "changedLines": 115147,
+            "durationSeconds": 85.89585675000001,
+            "stableNames": 13284
         }
-    }
+    },
+    "recommended": true,
+    "recommendedOrder": 2
 }

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

@@ -10,11 +10,29 @@ import { isFactoryCallback } from "./is-factory-callback.js";
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 const traverse = require("@babel/traverse").default;
-/**
- * Checks if a name looks like a stabilized top-level binding ($h_...)
- */
-const isStabilizedTopLevel = (name) => {
-    return name.startsWith("$h_");
+const renameCallbackLocalBindings = (path) => {
+    // Check if first argument is a function (the callback)
+    const callArguments = path.node.arguments;
+    if (callArguments.length === 0)
+        return 0;
+    const firstArgument = callArguments[0];
+    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;
+    // Skip renaming if callback contains dynamic name lookup (eval, with, etc.)
+    if (hasDynamicNameLookup(functionArgumentPath))
+        return 0;
+    // Collect and rename local bindings
+    const candidates = collectFactoryBindings(functionArgumentPath);
+    return applyRenames(candidates);
 };
 export const stabilizeNestedBindingsTransform = {
     id: "stabilize-nested-bindings",
@@ -29,34 +47,11 @@ export const stabilizeNestedBindingsTransform = {
             traverse(fileInfo.ast, {
                 CallExpression(path) {
                     nodesVisited++;
-                    // Check if callee is a stabilized top-level function ($h_...)
-                    const callee = path.node.callee;
-                    if (!t.isIdentifier(callee))
-                        return;
-                    if (!isStabilizedTopLevel(callee.name))
-                        return;
-                    // Check if first argument is a function (the factory callback)
-                    const callArguments = path.node.arguments;
-                    if (callArguments.length === 0)
-                        return;
-                    const firstArgument = callArguments[0];
-                    if (!t.isFunctionExpression(firstArgument) &&
-                        !t.isArrowFunctionExpression(firstArgument))
-                        return;
-                    // Verify it looks like a factory callback
-                    if (!isFactoryCallback(firstArgument))
-                        return;
-                    // Get the path to the function argument
-                    const functionArgumentPath = path.get("arguments.0");
-                    if (!functionArgumentPath.isFunctionExpression() &&
-                        !functionArgumentPath.isArrowFunctionExpression())
-                        return;
-                    // Skip renaming if factory contains dynamic name lookup (eval, with, etc.)
-                    if (hasDynamicNameLookup(functionArgumentPath))
-                        return;
-                    // Collect and rename local bindings
-                    const candidates = collectFactoryBindings(functionArgumentPath);
-                    fileTransformations += applyRenames(candidates);
+                    fileTransformations += renameCallbackLocalBindings(path);
+                },
+                OptionalCallExpression(path) {
+                    nodesVisited++;
+                    fileTransformations += renameCallbackLocalBindings(path);
                 },
             });
             transformationsApplied += fileTransformations;

package/package.json

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