miniread 1.112.0 → 1.114.0

package/dist/transforms/_generated/catalog.js

@@ -74,6 +74,8 @@ import { renameFileReaderVariablesTransform } from "../../transforms-by-id/renam
 import renameFileReaderVariablesManifest from "../../transforms-by-id/rename-file-reader-variables/manifest.json" with { type: "json" };
 import { renameFsSyncVariablesTransform } from "../../transforms-by-id/rename-fs-sync-variables/rename-fs-sync-variables-transform.js";
 import renameFsSyncVariablesManifest from "../../transforms-by-id/rename-fs-sync-variables/manifest.json" with { type: "json" };
+import { renameGitCommandResultsTransform } from "../../transforms-by-id/rename-git-command-results/rename-git-command-results-transform.js";
+import renameGitCommandResultsManifest from "../../transforms-by-id/rename-git-command-results/manifest.json" with { type: "json" };
 import { renameHttpMethodParametersTransform } from "../../transforms-by-id/rename-http-method-parameters/rename-http-method-parameters-transform.js";
 import renameHttpMethodParametersManifest from "../../transforms-by-id/rename-http-method-parameters/manifest.json" with { type: "json" };
 import { renameHttpServerParametersTransform } from "../../transforms-by-id/rename-http-server-parameters/rename-http-server-parameters-transform.js";
@@ -380,6 +382,11 @@ export const generatedTransformCatalog = [
         transform: renameFsSyncVariablesTransform,
         manifest: renameFsSyncVariablesManifest,
     },
+    {
+        id: renameGitCommandResultsTransform.id,
+        transform: renameGitCommandResultsTransform,
+        manifest: renameGitCommandResultsManifest,
+    },
     {
         id: renameHttpMethodParametersTransform.id,
         transform: renameHttpMethodParametersTransform,

package/dist/transforms/preset-stats.json

@@ -1,6 +1,6 @@
 {
     "recommended": {
-        "diffSizePercent": 26.062100767282757,
+        "diffSizePercent": 26.05643119023321,
         "notes": "Measured with baseline none: 26.06% of original diff."
     }
 }

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-command-result-variables/manifest.json

@@ -2,9 +2,9 @@
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
             "diffSizePercent": 100,
-            "evaluatedAt": "2026-02-13T08:14:27.481Z",
+            "evaluatedAt": "2026-02-14T12:53:18.669Z",
             "changedLines": 338,
-            "durationSeconds": 39.400678667,
+            "durationSeconds": 38.783343792,
             "stableNames": 1359
         }
     },

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-git-command-results/manifest.json

@@ -0,0 +1,13 @@
+{
+    "notes": "Pending evaluation.",
+    "evaluations": {
+        "claude-code-2.1.10:claude-code-2.1.11": {
+            "diffSizePercent": 100,
+            "evaluatedAt": "2026-02-14T12:52:39.042Z",
+            "changedLines": 350,
+            "durationSeconds": 39.629334792,
+            "stableNames": 1365
+        }
+    },
+    "recommended": false
+}

package/dist/transforms-by-id/rename-git-command-results/rename-git-command-results-transform.d.ts

@@ -0,0 +1,2 @@
+import { type Transform } from "../../core/types.js";
+export declare const renameGitCommandResultsTransform: Transform;

package/dist/transforms-by-id/rename-git-command-results/rename-git-command-results-transform.js

@@ -0,0 +1,110 @@
+import { createRequire } from "node:module";
+import { isStableRenamed, RenameGroup } from "../../core/stable-naming.js";
+import { getFilesToProcess, } from "../../core/types.js";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const traverse = require("@babel/traverse").default;
+const RESULT_PROPERTY_BASE_NAMES = {
+    code: "gitExitCode",
+    signal: "gitSignal",
+    stderr: "gitStderr",
+    stdout: "gitStdout",
+};
+const GIT_RESULT_BASE_NAME = "gitResult";
+const isResultPropertyName = (name) => Object.hasOwn(RESULT_PROPERTY_BASE_NAMES, name);
+const isGitCommandCall = (call) => {
+    const firstArgument = call.arguments[0];
+    if (!firstArgument)
+        return false;
+    if (firstArgument.type !== "StringLiteral")
+        return false;
+    return firstArgument.value === "git";
+};
+const getCallFromAwaitExpression = (expression) => {
+    if (expression.argument.type !== "CallExpression")
+        return undefined;
+    return expression.argument;
+};
+const getCallFromInitializer = (init) => {
+    if (!init)
+        return undefined;
+    if (init.type === "CallExpression")
+        return init;
+    if (init.type !== "AwaitExpression")
+        return undefined;
+    return getCallFromAwaitExpression(init);
+};
+const addObjectPatternRenames = (path, objectPattern, group) => {
+    for (const property of objectPattern.properties) {
+        if (property.type !== "ObjectProperty")
+            continue;
+        addObjectPropertyRename(path, property, group);
+    }
+};
+const addObjectPropertyRename = (path, property, group) => {
+    if (property.computed)
+        return;
+    if (property.key.type !== "Identifier")
+        return;
+    if (!isResultPropertyName(property.key.name))
+        return;
+    const value = property.value;
+    if (value.type !== "Identifier")
+        return;
+    if (isStableRenamed(value.name))
+        return;
+    const binding = path.scope.getBinding(value.name);
+    if (!binding)
+        return;
+    group.add({
+        scope: path.scope,
+        currentName: value.name,
+        baseName: RESULT_PROPERTY_BASE_NAMES[property.key.name],
+    });
+};
+const addIdentifierRename = (path, identifier, group) => {
+    if (isStableRenamed(identifier.name))
+        return;
+    const binding = path.scope.getBinding(identifier.name);
+    if (!binding)
+        return;
+    if (binding.referencePaths.length === 0)
+        return;
+    group.add({
+        scope: path.scope,
+        currentName: identifier.name,
+        baseName: GIT_RESULT_BASE_NAME,
+    });
+};
+export const renameGitCommandResultsTransform = {
+    id: "rename-git-command-results",
+    description: "Renames git command result bindings and destructured stdout/stderr/code/signal aliases to stable names",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const fileInfo of getFilesToProcess(context)) {
+            const group = new RenameGroup();
+            traverse(fileInfo.ast, {
+                VariableDeclarator(path) {
+                    nodesVisited++;
+                    const call = getCallFromInitializer(path.node.init);
+                    if (!call)
+                        return;
+                    if (!isGitCommandCall(call))
+                        return;
+                    if (path.node.id.type === "Identifier") {
+                        addIdentifierRename(path, path.node.id, group);
+                        return;
+                    }
+                    if (path.node.id.type !== "ObjectPattern")
+                        return;
+                    addObjectPatternRenames(path, path.node.id, group);
+                },
+            });
+            transformationsApplied += group.apply();
+        }
+        return Promise.resolve({ nodesVisited, transformationsApplied });
+    },
+};

package/dist/transforms-by-id/rename-promise-executor-parameters-v2/get-promise-executor-rename-plan.d.ts

@@ -3,9 +3,9 @@ import type { ArrowFunctionExpression, FunctionExpression } from "@babel/types";
 type PromiseExecutorRenamePlan = {
     bindingScope: Scope;
     fromResolveName: string;
-    fromRejectName: string;
+    fromRejectName: string | undefined;
     targetResolveName: string;
-    targetRejectName: string;
+    targetRejectName: string | undefined;
     wantsResolveRename: boolean;
     wantsRejectRename: boolean;
 };

package/dist/transforms-by-id/rename-promise-executor-parameters-v2/get-promise-executor-rename-plan.js

@@ -5,37 +5,42 @@ import { isAssignedToOnHandlerProperty, isCatchRejectionHandlerArgument, isDirec
 const STABLE_PREFIX = "$";
 export const getPromiseExecutorRenamePlan = (executorPath) => {
     const parameters = executorPath.node.params;
-    if (parameters.length !== 2)
+    if (parameters.length !== 1 && parameters.length !== 2)
         return;
     const [firstParameter, secondParameter] = parameters;
-    if (!firstParameter || !secondParameter)
+    if (!firstParameter)
         return;
     if (firstParameter.type !== "Identifier")
         return;
-    if (secondParameter.type !== "Identifier")
-        return;
     const resolveParameter = firstParameter;
-    const rejectParameter = secondParameter;
+    const rejectParameter = secondParameter?.type === "Identifier" ? secondParameter : undefined;
+    if (parameters.length === 2 && !rejectParameter)
+        return;
     // Non-strict scripts can allow duplicate parameter names like `function (a, a) {}`.
     // Babel models these as a single binding, so we can't safely rename parameters independently.
-    if (resolveParameter.name === rejectParameter.name)
+    if (resolveParameter.name === rejectParameter?.name)
         return;
     const targetResolveName = `${STABLE_PREFIX}resolve`;
-    const targetRejectName = `${STABLE_PREFIX}reject`;
+    const targetRejectName = rejectParameter
+        ? `${STABLE_PREFIX}reject`
+        : undefined;
     // Skip already-stable names, unless they already match the target stable names.
     // This allows completing a partially-stable executor like `($resolve, e)` → `($resolve, $reject)`.
     if (isStableRenamed(resolveParameter.name) &&
         resolveParameter.name !== targetResolveName) {
         return;
     }
-    if (isStableRenamed(rejectParameter.name) &&
+    if (rejectParameter &&
+        isStableRenamed(rejectParameter.name) &&
         rejectParameter.name !== targetRejectName) {
         return;
     }
     const bindingScope = executorPath.scope;
     const resolveBinding = bindingScope.getBinding(resolveParameter.name);
-    const rejectBinding = bindingScope.getBinding(rejectParameter.name);
-    if (!resolveBinding || !rejectBinding)
+    const rejectBinding = rejectParameter
+        ? bindingScope.getBinding(rejectParameter.name)
+        : undefined;
+    if (!resolveBinding || (rejectParameter && !rejectBinding))
         return;
     const resolveIsCalledOrThenHandled = resolveBinding.referencePaths.some((referencePath) => isDirectCallOfBinding(referencePath) ||
         isThenFulfillmentHandlerArgument(referencePath));
@@ -47,24 +52,30 @@ export const getPromiseExecutorRenamePlan = (executorPath) => {
     // unlike `reject` as an `"error"` handler, those patterns are lower-confidence and easier to misclassify.
     if (!resolveIsOnlyCalledOrThenHandled)
         return;
-    const rejectIsCalledOrHandled = rejectBinding.referencePaths.some((referencePath) => isDirectCallOfBinding(referencePath) ||
-        isThenRejectionHandlerArgument(referencePath) ||
-        isCatchRejectionHandlerArgument(referencePath));
-    const rejectIsOnHandler = rejectBinding.referencePaths.some((referencePath) => isAssignedToOnHandlerProperty(referencePath));
-    const rejectIsErrorHandler = rejectBinding.referencePaths.some((referencePath) => isErrorEventHandlerArgument(referencePath));
-    if (!rejectIsCalledOrHandled && !rejectIsOnHandler && !rejectIsErrorHandler) {
-        return;
+    if (rejectBinding) {
+        const rejectIsCalledOrHandled = rejectBinding.referencePaths.some((referencePath) => isDirectCallOfBinding(referencePath) ||
+            isThenRejectionHandlerArgument(referencePath) ||
+            isCatchRejectionHandlerArgument(referencePath));
+        const rejectIsOnHandler = rejectBinding.referencePaths.some((referencePath) => isAssignedToOnHandlerProperty(referencePath));
+        const rejectIsErrorHandler = rejectBinding.referencePaths.some((referencePath) => isErrorEventHandlerArgument(referencePath));
+        if (!rejectIsCalledOrHandled &&
+            !rejectIsOnHandler &&
+            !rejectIsErrorHandler) {
+            return;
+        }
+        const rejectIsOnlyCalledOrHandlerAssigned = rejectBinding.referencePaths.every((referencePath) => isDirectCallOfBinding(referencePath) ||
+            isThenRejectionHandlerArgument(referencePath) ||
+            isCatchRejectionHandlerArgument(referencePath) ||
+            isAssignedToOnHandlerProperty(referencePath) ||
+            isErrorEventHandlerArgument(referencePath) ||
+            isErrorEventHandlerRemovalArgument(referencePath));
+        if (!rejectIsOnlyCalledOrHandlerAssigned)
+            return;
     }
-    const rejectIsOnlyCalledOrHandlerAssigned = rejectBinding.referencePaths.every((referencePath) => isDirectCallOfBinding(referencePath) ||
-        isThenRejectionHandlerArgument(referencePath) ||
-        isCatchRejectionHandlerArgument(referencePath) ||
-        isAssignedToOnHandlerProperty(referencePath) ||
-        isErrorEventHandlerArgument(referencePath) ||
-        isErrorEventHandlerRemovalArgument(referencePath));
-    if (!rejectIsOnlyCalledOrHandlerAssigned)
-        return;
     const wantsResolveRename = resolveParameter.name !== targetResolveName;
-    const wantsRejectRename = rejectParameter.name !== targetRejectName;
+    const wantsRejectRename = rejectParameter && targetRejectName
+        ? rejectParameter.name !== targetRejectName
+        : false;
     // Nothing to do: both parameters are already the stable target names.
     if (!wantsResolveRename && !wantsRejectRename)
         return;
@@ -73,9 +84,10 @@ export const getPromiseExecutorRenamePlan = (executorPath) => {
     const resolveWouldShadow = wantsResolveRename &&
         wouldShadowReferencedOuterBinding(executorPath, targetResolveName);
     const rejectWouldShadow = wantsRejectRename &&
+        targetRejectName !== undefined &&
         wouldShadowReferencedOuterBinding(executorPath, targetRejectName);
     const fromResolveName = resolveParameter.name;
-    const fromRejectName = rejectParameter.name;
+    const fromRejectName = rejectParameter?.name;
     const canRenameResolve = !wantsResolveRename ||
         (!resolveWouldShadow &&
             canRenameBindingSafely(bindingScope, fromResolveName, targetResolveName, {
@@ -83,6 +95,8 @@ export const getPromiseExecutorRenamePlan = (executorPath) => {
             }));
     const canRenameReject = !wantsRejectRename ||
         (!rejectWouldShadow &&
+            fromRejectName !== undefined &&
+            targetRejectName !== undefined &&
             canRenameBindingSafely(bindingScope, fromRejectName, targetRejectName, {
                 strictMode: false,
             }));

package/dist/transforms-by-id/rename-promise-executor-parameters-v2/manifest.json

@@ -3,9 +3,9 @@
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
             "diffSizePercent": 99.99623032701913,
-            "evaluatedAt": "2026-02-09T14:05:34.662Z",
-            "changedLines": 1432,
-            "durationSeconds": 176.089765559,
+            "evaluatedAt": "2026-02-13T08:17:00.590Z",
+            "changedLines": 1880,
+            "durationSeconds": 184.31310626599998,
             "stableNames": 1359
         }
     },

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

@@ -31,14 +31,14 @@ export const getExecutorFunctionIfEligible = (path) => {
         return;
     }
     const parameters = executor.node.params;
-    if (parameters.length !== 2)
+    if (parameters.length !== 1 && parameters.length !== 2)
         return;
     const [firstParameter, secondParameter] = parameters;
-    if (!firstParameter || !secondParameter)
+    if (!firstParameter)
         return;
     if (firstParameter.type !== "Identifier")
         return;
-    if (secondParameter.type !== "Identifier")
+    if (secondParameter !== undefined && secondParameter.type !== "Identifier")
         return;
     // v1 checked that the *source* parameter names are valid identifiers, but this is redundant:
     // if Babel produced Identifier nodes under `sourceType: "unambiguous"` parsing, then the names

package/dist/transforms-by-id/rename-promise-executor-parameters-v2/rename-promise-executor-parameters-v2-transform.js

@@ -36,6 +36,10 @@ export const renamePromiseExecutorParametersV2Transform = {
                         renamedResolve = true;
                     }
                     if (renamePlan.wantsRejectRename) {
+                        if (renamePlan.fromRejectName === undefined ||
+                            renamePlan.targetRejectName === undefined) {
+                            return;
+                        }
                         renamePlan.bindingScope.rename(renamePlan.fromRejectName, renamePlan.targetRejectName);
                         renamedReject = true;
                     }

package/dist/transforms-by-id/rename-timeout-ids/manifest.json

@@ -1,14 +1,14 @@
 {
-    "recommended": true,
-    "recommendedOrder": 100,
-    "notes": "Measured with baseline none: 0.00%. Added to recommended for readability.",
+    "notes": "Generalized timer-handle rename transform for setTimeout and setInterval. Measured with baseline none: 0.00%. Added to recommended for readability.",
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
-            "diffSizePercent": 99.99623032701913,
-            "evaluatedAt": "2026-02-07T21:15:56.221Z",
-            "changedLines": 154,
-            "durationSeconds": 159.140358367,
-            "stableNames": 1358
+            "diffSizePercent": 99.99622028196697,
+            "evaluatedAt": "2026-02-14T12:54:44.910Z",
+            "changedLines": 200,
+            "durationSeconds": 38.705412083000006,
+            "stableNames": 1359
         }
-    }
+    },
+    "recommended": true,
+    "recommendedOrder": 100
 }

package/dist/transforms-by-id/rename-timeout-ids/rename-timeout-ids-transform.js

@@ -4,18 +4,33 @@ import { getFilesToProcess, } from "../../core/types.js";
 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 = "timeoutId";
-const isSetTimeoutCall = (path, init) => {
-    if (init.callee.type !== "Identifier")
-        return false;
-    if (init.callee.name !== "setTimeout")
-        return false;
-    // If setTimeout is locally bound (imported or declared), semantics may differ.
-    if (path.scope.hasBinding("setTimeout", true))
-        return false;
-    return true;
+const TIMER_HANDLE_RENAME_RULES = [
+    {
+        setName: "setTimeout",
+        clearName: "clearTimeout",
+        baseName: "timeoutId",
+        batch: "timeout",
+    },
+    {
+        setName: "setInterval",
+        clearName: "clearInterval",
+        baseName: "intervalId",
+        batch: "interval",
+    },
+];
+const getTimerHandleRenameRule = (path, init) => {
+    const callee = init.callee;
+    if (callee.type !== "Identifier")
+        return undefined;
+    const renameRule = TIMER_HANDLE_RENAME_RULES.find((rule) => rule.setName === callee.name);
+    if (!renameRule)
+        return undefined;
+    // If timer constructor is locally bound (imported or declared), semantics may differ.
+    if (path.scope.hasBinding(renameRule.setName, true))
+        return undefined;
+    return renameRule;
 };
-const isClearTimeoutCallArgument = (referencePath, bindingName) => {
+const isMatchingClearCallArgument = (referencePath, bindingName, renameRule) => {
     if (!referencePath.isIdentifier())
         return false;
     const callPath = referencePath.parentPath;
@@ -24,10 +39,10 @@ const isClearTimeoutCallArgument = (referencePath, bindingName) => {
     const call = callPath.node;
     if (call.callee.type !== "Identifier")
         return false;
-    if (call.callee.name !== "clearTimeout")
+    if (call.callee.name !== renameRule.clearName)
         return false;
-    // If clearTimeout is locally bound (imported or declared), semantics may differ.
-    if (callPath.scope.hasBinding("clearTimeout", true))
+    // If clear function is locally bound (imported or declared), semantics may differ.
+    if (callPath.scope.hasBinding(renameRule.clearName, true))
         return false;
     const argument0 = call.arguments[0];
     if (argument0?.type !== "Identifier")
@@ -40,14 +55,15 @@ const isClearTimeoutCallArgument = (referencePath, bindingName) => {
 };
 export const renameTimeoutIdsTransform = {
     id: "rename-timeout-ids",
-    description: "Renames setTimeout handle variables to $timeoutId/$timeoutId2/... or timeoutId/timeoutId2/... when usage is only clearTimeout(...)",
+    description: "Renames setTimeout/setInterval handle variables to stable timer names when usage is only clearTimeout(...) or clearInterval(...)",
     scope: "file",
     parallelizable: true,
     transform(context) {
         let nodesVisited = 0;
         let transformationsApplied = 0;
         for (const fileInfo of getFilesToProcess(context)) {
-            const group = new RenameGroup();
+            const intervalRenameGroup = new RenameGroup();
+            const timeoutRenameGroup = new RenameGroup();
             traverse(fileInfo.ast, {
                 VariableDeclarator(path) {
                     nodesVisited++;
@@ -60,7 +76,8 @@ export const renameTimeoutIdsTransform = {
                     const init = path.node.init;
                     if (init?.type !== "CallExpression")
                         return;
-                    if (!isSetTimeoutCall(path, init))
+                    const renameRule = getTimerHandleRenameRule(path, init);
+                    if (!renameRule)
                         return;
                     const binding = path.scope.getBinding(id.name);
                     if (!binding)
@@ -69,16 +86,22 @@ export const renameTimeoutIdsTransform = {
                         return;
                     if (binding.referencePaths.length === 0)
                         return;
-                    if (!binding.referencePaths.every((referencePath) => isClearTimeoutCallArgument(referencePath, id.name)))
+                    if (!binding.referencePaths.every((referencePath) => isMatchingClearCallArgument(referencePath, id.name, renameRule)))
                         return;
-                    group.add({
+                    const renameGroup = renameRule.batch === "interval"
+                        ? intervalRenameGroup
+                        : timeoutRenameGroup;
+                    renameGroup.add({
                         scope: path.scope,
                         currentName: id.name,
-                        baseName: BASE_NAME,
+                        baseName: renameRule.baseName,
                     });
                 },
             });
-            transformationsApplied += group.apply();
+            // Preserve pre-generalization ordering: interval handle renames first,
+            // timeout handle renames second.
+            transformationsApplied += intervalRenameGroup.apply();
+            transformationsApplied += timeoutRenameGroup.apply();
         }
         return Promise.resolve({ nodesVisited, transformationsApplied });
     },

package/package.json

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