miniread 1.113.0 → 1.115.0

package/dist/transforms/preset-stats.json

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

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

@@ -1,11 +1,11 @@
 {
-    "notes": "Renames variables initialized as empty arrays with .push() usage to stable/readable names.",
+    "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.95275352458707,
-            "evaluatedAt": "2026-02-12T07:32:40.071Z",
-            "changedLines": 9226,
-            "durationSeconds": 44.1652115,
+            "diffSizePercent": 99.94708394753752,
+            "evaluatedAt": "2026-02-17T08:05:01.672Z",
+            "changedLines": 9338,
+            "durationSeconds": 41.067913833,
             "stableNames": 1360
         }
     },

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

@@ -6,22 +6,24 @@ const require = createRequire(import.meta.url);
 const traverse = require("@babel/traverse").default;
 const BASE_NAME = "results";
 /**
- * Checks whether a binding reference is a `.push()` call on the variable.
- * Matches: `X.push(...)` where X is the binding.
+ * 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 isPushCallReference = (referencePath) => {
+const isAccumulatorMutationReference = (referencePath) => {
     const memberPath = referencePath.parentPath;
     if (!memberPath?.isMemberExpression())
         return false;
-    // Must be X.push (not X[push] or X["push"])
+    // Must be X.push/X.unshift (not X[push] or X["push"])
     if (memberPath.node.computed)
         return false;
     if (memberPath.node.object !== referencePath.node)
         return false;
     const property = memberPath.node.property;
-    if (property.type !== "Identifier" || property.name !== "push")
+    if (property.type !== "Identifier")
         return false;
-    // The member expression must be called: X.push(...)
+    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;
@@ -30,15 +32,15 @@ const isPushCallReference = (referencePath) => {
     return true;
 };
 /**
- * Checks whether a binding has at least one `.push()` call reference,
+ * Checks whether a binding has at least one array mutation call reference,
  * confirming the accumulator pattern.
  */
-const hasAtLeastOnePushCall = (referencePaths) => {
-    return referencePaths.some((path) => isPushCallReference(path));
+const hasAtLeastOneAccumulatorMutation = (referencePaths) => {
+    return referencePaths.some((path) => isAccumulatorMutationReference(path));
 };
 export const renameArrayAccumulatorVariablesTransform = {
     id: "rename-array-accumulator-variables",
-    description: "Renames variables initialized as empty arrays with .push() usage to $results/$results2/... or results/results2/...",
+    description: "Renames variables initialized as empty arrays with .push()/.unshift() usage to $results/$results2/... or results/results2/...",
     scope: "file",
     parallelizable: true,
     transform(context) {
@@ -72,8 +74,8 @@ export const renameArrayAccumulatorVariablesTransform = {
                     // Must have at least one reference
                     if (binding.referencePaths.length === 0)
                         return;
-                    // Must have at least one .push() call to confirm accumulator pattern
-                    if (!hasAtLeastOnePushCall(binding.referencePaths))
+                    // Must have at least one array mutation call to confirm accumulator pattern
+                    if (!hasAtLeastOneAccumulatorMutation(binding.referencePaths))
                         return;
                     group.add({
                         scope: path.scope,

package/dist/transforms-by-id/rename-deferred-resolve-parameters-v2/deferred-executor-heuristics.d.ts

@@ -1,5 +1,6 @@
 import type { NodePath } from "@babel/traverse";
 import type { ArrowFunctionExpression, FunctionExpression, NewExpression } from "@babel/types";
 export declare const getExecutorFunctionIfEligible: (path: NodePath<NewExpression>) => NodePath<FunctionExpression | ArrowFunctionExpression> | undefined;
-export declare const isStoredReference: (referencePath: NodePath) => boolean;
+export declare const isResolvePromiseLikeReference: (referencePath: NodePath) => boolean;
+export declare const isRejectPromiseLikeReference: (referencePath: NodePath) => boolean;
 export declare const wouldShadowReferencedOuterBinding: (executorPath: NodePath<FunctionExpression | ArrowFunctionExpression>, targetName: string) => boolean;

package/dist/transforms-by-id/rename-deferred-resolve-parameters-v2/deferred-executor-heuristics.js

@@ -1,3 +1,4 @@
+import { isAssignedToOnHandlerProperty, isCatchRejectionHandlerArgument, isDirectCallOfBinding, isErrorEventHandlerArgument, isErrorEventHandlerRemovalArgument, isThenFulfillmentHandlerArgument, isThenRejectionHandlerArgument, } from "../rename-promise-executor-parameters-v2/promise-executor-heuristics.js";
 import { isValidBindingIdentifier } from "./is-valid-binding-identifier.js";
 const isExecutorParameterEligible = (parameter) => {
     if (!isValidBindingIdentifier(parameter.name))
@@ -63,14 +64,27 @@ const isVariableDeclaratorInitReference = (referencePath) => {
         return false;
     return referencePath.key === "init";
 };
-export const isStoredReference = (referencePath) => {
-    // Keep this narrow on purpose: direct call-argument passing (e.g. `queue.push(resolve)`) is
-    // excluded as lower-confidence. We still allow identifiers inside array/object literals
-    // (e.g. `queue.push([resolve, reject])`) because those references are explicit storage sites.
-    return (isArrayElementReference(referencePath) ||
-        isObjectPropertyValueReference(referencePath) ||
-        isAssignmentValueReference(referencePath) ||
-        isVariableDeclaratorInitReference(referencePath));
+const isStoredReference = (referencePath) => isArrayElementReference(referencePath) ||
+    isObjectPropertyValueReference(referencePath) ||
+    isAssignmentValueReference(referencePath) ||
+    isVariableDeclaratorInitReference(referencePath);
+export const isResolvePromiseLikeReference = (referencePath) => {
+    if (!referencePath.isIdentifier())
+        return false;
+    return (isStoredReference(referencePath) ||
+        isDirectCallOfBinding(referencePath) ||
+        isThenFulfillmentHandlerArgument(referencePath));
+};
+export const isRejectPromiseLikeReference = (referencePath) => {
+    if (!referencePath.isIdentifier())
+        return false;
+    return (isStoredReference(referencePath) ||
+        isDirectCallOfBinding(referencePath) ||
+        isThenRejectionHandlerArgument(referencePath) ||
+        isCatchRejectionHandlerArgument(referencePath) ||
+        isAssignedToOnHandlerProperty(referencePath) ||
+        isErrorEventHandlerArgument(referencePath) ||
+        isErrorEventHandlerRemovalArgument(referencePath));
 };
 export const wouldShadowReferencedOuterBinding = (executorPath, targetName) => {
     const parentBinding = executorPath.scope.getBinding(targetName);

package/dist/transforms-by-id/rename-deferred-resolve-parameters-v2/manifest.json

@@ -2,10 +2,10 @@
     "notes": "Renames deferred promise executor parameters to $resolve/$reject when both are only stored.",
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
-            "diffSizePercent": 100,
-            "evaluatedAt": "2026-02-10T20:26:59.436Z",
-            "changedLines": 92,
-            "durationSeconds": 36.222931665999994,
+            "diffSizePercent": 99.99244056393393,
+            "evaluatedAt": "2026-02-16T08:21:48.869Z",
+            "changedLines": 1670,
+            "durationSeconds": 40.99589079100001,
             "stableNames": 1359
         }
     },

package/dist/transforms-by-id/rename-deferred-resolve-parameters-v2/rename-deferred-resolve-parameters-v2-transform.js

@@ -1,7 +1,7 @@
 import { createRequire } from "node:module";
 import { isStableRenamed } from "../../core/stable-naming.js";
 import { getFilesToProcess, } from "../../core/types.js";
-import { getExecutorFunctionIfEligible, isStoredReference, wouldShadowReferencedOuterBinding, } from "./deferred-executor-heuristics.js";
+import { getExecutorFunctionIfEligible, isRejectPromiseLikeReference, isResolvePromiseLikeReference, wouldShadowReferencedOuterBinding, } from "./deferred-executor-heuristics.js";
 import { hasExecutorLocalDynamicNameLookup } from "./has-executor-local-dynamic-name-lookup.js";
 import { canRenameBindingSafely } from "./rename-binding-if-safe.js";
 const require = createRequire(import.meta.url);
@@ -10,7 +10,7 @@ const traverse = require("@babel/traverse").default;
 const STABLE_PREFIX = "$";
 export const renameDeferredResolveParametersV2Transform = {
     id: "rename-deferred-resolve-parameters-v2",
-    description: "Renames deferred promise resolve/reject parameters to $resolve/$reject when each parameter is only stored or unused",
+    description: "Renames deferred promise resolve/reject parameters to $resolve/$reject when safe",
     scope: "file",
     parallelizable: true,
     transform(context) {
@@ -60,28 +60,29 @@ export const renameDeferredResolveParametersV2Transform = {
                     const rejectBinding = bindingScope.getBinding(rejectParameter.name);
                     if (!resolveBinding || !rejectBinding)
                         return;
-                    if (resolveBinding.constantViolations.length > 0)
-                        return;
-                    if (rejectBinding.constantViolations.length > 0)
-                        return;
-                    const resolveHasReferences = resolveBinding.referencePaths.length > 0;
-                    const rejectHasReferences = rejectBinding.referencePaths.length > 0;
                     const resolveReferencePaths = resolveBinding.referencePaths;
                     const rejectReferencePaths = rejectBinding.referencePaths;
                     const hasUsageSignal = resolveReferencePaths.length > 0 || rejectReferencePaths.length > 0;
                     if (!hasUsageSignal)
                         return;
-                    const resolveIsStoredOnly = resolveReferencePaths.every((referencePath) => referencePath.isIdentifier() && isStoredReference(referencePath));
-                    if (!resolveIsStoredOnly)
+                    const resolveHasOnlyPromiseLikeReferences = resolveReferencePaths.every((referencePath) => isResolvePromiseLikeReference(referencePath));
+                    if (!resolveHasOnlyPromiseLikeReferences)
                         return;
-                    const rejectIsStoredOnly = rejectReferencePaths.every((referencePath) => referencePath.isIdentifier() && isStoredReference(referencePath));
-                    if (!rejectIsStoredOnly)
+                    const rejectHasOnlyPromiseLikeReferences = rejectReferencePaths.every((referencePath) => isRejectPromiseLikeReference(referencePath));
+                    if (!rejectHasOnlyPromiseLikeReferences)
                         return;
-                    // Avoid introducing semantic names for never-used parameters.
-                    const wantsResolveRename = resolveHasReferences && resolveParameter.name !== targetResolveName;
-                    const wantsRejectRename = rejectHasReferences && rejectParameter.name !== targetRejectName;
+                    const wantsResolveRename = resolveParameter.name !== targetResolveName;
+                    const wantsRejectRename = rejectParameter.name !== targetRejectName;
                     if (!wantsResolveRename && !wantsRejectRename)
                         return;
+                    if (wantsResolveRename &&
+                        resolveBinding.constantViolations.length > 0) {
+                        return;
+                    }
+                    if (wantsRejectRename &&
+                        rejectBinding.constantViolations.length > 0) {
+                        return;
+                    }
                     // Shadowing checks require a full traversal of the executor, so only do them for parameters
                     // that actually need renaming.
                     const resolveWouldShadow = wantsResolveRename &&

package/dist/transforms-by-id/rename-loop-index-variables-v3/get-loop-counter-name.js

@@ -105,8 +105,6 @@ export const getStableRenamedIndexLoopCounterName = (path) => {
             continue;
         if (declarator.init.type !== "NumericLiteral")
             continue;
-        if (declarator.init.value !== 0)
-            continue;
         if (!isLoopCounterDeclarator(loopCounterName, path))
             continue;
         if (stableName !== undefined)
@@ -133,8 +131,6 @@ export const getLoopCounterNameIfEligible = (path) => {
             continue;
         if (declarator.init.type !== "NumericLiteral")
             continue;
-        if (declarator.init.value !== 0)
-            continue;
         const loopCounterName = declarator.id.name;
         if (!isLoopCounterDeclarator(loopCounterName, path))
             continue;

package/dist/transforms-by-id/rename-loop-index-variables-v3/manifest.json

@@ -3,9 +3,9 @@
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
             "diffSizePercent": 100,
-            "evaluatedAt": "2026-02-10T17:29:03.499Z",
-            "changedLines": 3478,
-            "durationSeconds": 60.688113084,
+            "evaluatedAt": "2026-02-14T13:04:12.173Z",
+            "changedLines": 3626,
+            "durationSeconds": 180.525304795,
             "stableNames": 1361
         }
     },

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

@@ -4,7 +4,6 @@ type BindingCandidate = {
     binding: Binding;
     currentName: string;
     baseName: string;
-    conflicted: boolean;
 };
 type CollectReturnObjectBindingCandidatesResult = {
     candidates: Map<Binding, BindingCandidate>;
@@ -12,7 +11,6 @@ type CollectReturnObjectBindingCandidatesResult = {
 };
 type CollectReturnObjectBindingCandidatesOptions = {
     ast: File;
-    isScript: boolean;
     exportedNames: ReadonlySet<string>;
 };
 export declare const collectReturnObjectBindingCandidates: (options: CollectReturnObjectBindingCandidatesOptions) => CollectReturnObjectBindingCandidatesResult;

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

@@ -25,8 +25,6 @@ const collectCandidatesForObjectExpression = (options) => {
         const propertyName = getPropertyName(property.key);
         if (!propertyName)
             continue;
-        if (propertyName.length <= 1)
-            continue;
         if (!isValidBindingIdentifier(propertyName))
             continue;
         if (isHashBasedStableName(`$${propertyName}`))
@@ -53,23 +51,18 @@ const collectCandidatesForObjectExpression = (options) => {
             exportedNames.has(currentName)) {
             continue;
         }
-        const existing = candidates.get(binding);
-        if (existing) {
-            if (existing.baseName !== propertyName) {
-                existing.conflicted = true;
-            }
+        if (candidates.has(binding))
             continue;
-        }
         candidates.set(binding, {
             binding,
             currentName,
             baseName: propertyName,
-            conflicted: false,
         });
     }
 };
 export const collectReturnObjectBindingCandidates = (options) => {
-    const { ast, isScript, exportedNames } = options;
+    const { ast, exportedNames } = options;
+    const isScript = ast.program.sourceType === "script";
     let nodesVisited = 0;
     const candidates = new Map();
     traverse(ast, {

package/dist/transforms-by-id/rename-return-object-bindings/manifest.json

@@ -1,11 +1,11 @@
 {
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
-            "diffSizePercent": 99.87715916392636,
-            "evaluatedAt": "2026-02-12T09:10:04.050Z",
-            "changedLines": 13347,
-            "durationSeconds": 44.633210875,
-            "stableNames": 2444
+            "diffSizePercent": 99.88282874097592,
+            "evaluatedAt": "2026-02-17T12:48:21.759Z",
+            "changedLines": 13827,
+            "durationSeconds": 47.550179875,
+            "stableNames": 2458
         }
     },
     "recommended": true,

package/dist/transforms-by-id/rename-return-object-bindings/rename-return-object-bindings-transform.js

@@ -30,15 +30,12 @@ export const renameReturnObjectBindingsTransform = {
             const exportedNames = collectExportedNames(fileInfo.ast.program);
             const { candidates, nodesVisited: fileNodesVisited } = collectReturnObjectBindingCandidates({
                 ast: fileInfo.ast,
-                isScript,
                 exportedNames,
             });
             nodesVisited += fileNodesVisited;
             const dynamicLookupScopes = collectLocalDynamicLookupScopes(fileInfo.ast);
             const group = new RenameGroup();
             for (const candidate of candidates.values()) {
-                if (candidate.conflicted)
-                    continue;
                 if (candidate.binding.scope.block.type === "Program"
                     ? hasProgramScopeDynamicNameLookup
                     : hasBindingLocalDynamicNameLookup(candidate.binding, candidate.currentName, dynamicLookupScopes)) {

package/dist/transforms-by-id/stabilize-deferred-top-level-bindings/collect-deferred-variables.d.ts

@@ -5,6 +5,7 @@ type DeferredVariableInfo = {
     enclosingFunctionName: string;
     enclosingFunctionScopeUid: number;
     scope: Scope;
+    declarationStart: number | undefined;
 };
 /**
  * Collect information about deferred top-level var declarations.
@@ -16,8 +17,8 @@ export declare const collectDeferredVariables: (ast: t.File, programScope: Scope
     nodesVisited: number;
 };
 /**
- * Group deferred vars by their enclosing function.
- * Returns only vars where the function has exactly ONE deferred var.
+ * Group deferred vars by enclosing function and select one deterministic
+ * candidate for each function.
  */
-export declare const filterToSingleVariableFunctions: (deferredVariables: DeferredVariableInfo[]) => DeferredVariableInfo[];
+export declare const selectDeferredVariablesForRename: (deferredVariables: DeferredVariableInfo[]) => DeferredVariableInfo[];
 export {};

package/dist/transforms-by-id/stabilize-deferred-top-level-bindings/collect-deferred-variables.js

@@ -87,6 +87,7 @@ export const collectDeferredVariables = (ast, programScope) => {
                     enclosingFunctionName: info.enclosingFunctionName,
                     enclosingFunctionScopeUid: info.enclosingFunctionScopeUid,
                     scope: binding.scope,
+                    declarationStart: binding.identifier.start ?? undefined,
                 });
             }
         }
@@ -94,10 +95,10 @@ export const collectDeferredVariables = (ast, programScope) => {
     return { deferredVariables, nodesVisited };
 };
 /**
- * Group deferred vars by their enclosing function.
- * Returns only vars where the function has exactly ONE deferred var.
+ * Group deferred vars by enclosing function and select one deterministic
+ * candidate for each function.
  */
-export const filterToSingleVariableFunctions = (deferredVariables) => {
+export const selectDeferredVariablesForRename = (deferredVariables) => {
     // Group by enclosing function identity (name + scope UID).
     const byFunction = new Map();
     for (const info of deferredVariables) {
@@ -110,12 +111,33 @@ export const filterToSingleVariableFunctions = (deferredVariables) => {
             byFunction.set(functionIdentity, [info]);
         }
     }
-    // Only keep vars where function has exactly one
+    // Keep one candidate per function:
+    // - Skip already-stable bindings (`$...`) to avoid churn.
+    // - For multi-candidate functions, pick the earliest declaration position.
+    //   This tie-break is independent of minified identifier text.
     const result = [];
     for (const variables of byFunction.values()) {
-        if (variables.length === 1 && variables[0]) {
-            result.push(variables[0]);
+        const unstabilizedVariables = variables.filter((variableInfo) => !isStableRenamed(variableInfo.variableName));
+        if (unstabilizedVariables.length === 0)
+            continue;
+        if (unstabilizedVariables.length === 1 && unstabilizedVariables[0]) {
+            result.push(unstabilizedVariables[0]);
+            continue;
         }
+        const sortedByDeclarationStart = unstabilizedVariables.toSorted((left, right) => {
+            const leftStart = left.declarationStart ?? Number.POSITIVE_INFINITY;
+            const rightStart = right.declarationStart ?? Number.POSITIVE_INFINITY;
+            return leftStart - rightStart;
+        });
+        const first = sortedByDeclarationStart[0];
+        const second = sortedByDeclarationStart[1];
+        if (!first)
+            continue;
+        const firstStart = first.declarationStart ?? Number.POSITIVE_INFINITY;
+        const secondStart = second?.declarationStart ?? Number.POSITIVE_INFINITY;
+        if (firstStart === secondStart)
+            continue;
+        result.push(first);
     }
     return result;
 };

package/dist/transforms-by-id/stabilize-deferred-top-level-bindings/manifest.json

@@ -1,12 +1,12 @@
 {
-    "notes": "Stabilizes top-level var declarations that are initialized inside stable-named functions (lazy init pattern). Only applies when the enclosing function has exactly one such deferred var to avoid order-dependent naming. Renames ~750 vars but diff reduction is minimal (0.03%) because most vars already have consistent minified names between versions. The stabilization helps when minifiers do vary names.",
+    "notes": "Stabilizes top-level var declarations initialized inside stable-named functions (lazy init pattern). For multi-deferred functions, picks a deterministic candidate by declaration order and skips already-stable `$...` bindings to avoid churn from minifier-dependent variable names.",
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
-            "diffSizePercent": 100.13606984918925,
-            "evaluatedAt": "2026-02-10T06:27:28.231Z",
-            "changedLines": 126,
-            "durationSeconds": 39.356983667,
-            "stableNames": 1367
+            "diffSizePercent": 100.24568167214727,
+            "evaluatedAt": "2026-02-17T12:58:15.137Z",
+            "changedLines": 448,
+            "durationSeconds": 44.418337541,
+            "stableNames": 1380
         }
     },
     "recommended": true,

package/dist/transforms-by-id/stabilize-deferred-top-level-bindings/stabilize-deferred-top-level-bindings-transform.js

@@ -2,7 +2,7 @@ import { createRequire } from "node:module";
 import { parse } from "@babel/parser";
 import { getFilesToProcess, } from "../../core/types.js";
 import { generateCode } from "../../core/generate-code.js";
-import { collectDeferredVariables, filterToSingleVariableFunctions, } from "./collect-deferred-variables.js";
+import { collectDeferredVariables, selectDeferredVariablesForRename, } from "./collect-deferred-variables.js";
 import { extractHashFromStableName, renameBindingInPlace, } from "./rename-helpers.js";
 import { canRenameBindingSafely } from "../../transforms/shared/can-rename-binding-safely.js";
 const require = createRequire(import.meta.url);
@@ -11,8 +11,8 @@ const traverse = require("@babel/traverse").default;
 export const stabilizeDeferredTopLevelBindingsTransform = {
     id: "stabilize-deferred-top-level-bindings",
     description: "Renames top-level var declarations without initializers (deferred bindings) to stable names " +
-        "derived from their enclosing stable function. Only applies when the function has exactly one " +
-        "such deferred var to avoid order-dependent naming.",
+        "derived from their enclosing stable function. For functions with multiple deferred vars, " +
+        "chooses a deterministic candidate by declaration order and skips already-stable bindings.",
     scope: "file",
     parallelizable: true,
     transform(context) {
@@ -33,8 +33,8 @@ export const stabilizeDeferredTopLevelBindingsTransform = {
             // Collect deferred vars
             const { deferredVariables, nodesVisited: fileNodesVisited } = collectDeferredVariables(fileInfo.ast, programScope);
             nodesVisited += fileNodesVisited;
-            // Filter to vars where function has exactly one deferred var
-            const eligibleVariables = filterToSingleVariableFunctions(deferredVariables);
+            // Select one deterministic deferred var candidate per function.
+            const eligibleVariables = selectDeferredVariablesForRename(deferredVariables);
             // Apply renames. Track used names for consistency with stabilize-deferred-stable-rhs
             // and to avoid duplicate `$v_...` targets when different functions produce
             // the same derived hash.

package/package.json

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