miniread 1.114.0 → 1.115.0

package/dist/transforms/preset-stats.json

@@ -1,6 +1,6 @@
 {
     "recommended": {
-        "diffSizePercent": 26.05643119023321,
-        "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-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.114.0",
+  "version": "1.115.0",
   "description": "Transform minified JavaScript/TypeScript into a more readable form using deterministic AST-based transforms.",
   "repository": {
     "type": "git",