miniread 1.48.0 → 1.50.0

package/dist/transforms/_generated/manifest.js

@@ -138,7 +138,7 @@ const manifestData = {
     "rename-object-keys-variables": {
         recommended: true,
         notes: "Measured with baseline none: 0.01%. Added to recommended for readability.",
-        evaluations: { "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 99.99244056393393, "evaluatedAt": "2026-01-26T07:04:46.335Z", "changedLines": 602, "durationSeconds": 121.114895708, "stableNames": 1358 } },
+        evaluations: { "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 99.99244056393393, "evaluatedAt": "2026-01-27T06:42:06.193Z", "changedLines": 602, "durationSeconds": 165.514278459, "stableNames": 1358 } },
     },
     "rename-parameters-to-match-properties": {
         recommended: false,
@@ -157,10 +157,16 @@ const manifestData = {
         evaluations: { "legacy:evaluation": { "evaluatedAt": "2026-01-25T20:07:50.099Z", "changedLines": 8, "durationSeconds": 0, "stableNames": 0, "diffSizePercent": 100 }, "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 100, "evaluatedAt": "2026-01-25T23:25:19.956Z", "changedLines": 8, "durationSeconds": 44.331720583, "stableNames": 1360 } },
     },
     "rename-promise-executor-parameters": {
-        recommended: true,
-        notes: "Auto-added by evaluation script.",
+        recommended: false,
+        notes: "Superseded by rename-promise-executor-parameters-v2. Known issue: can produce incorrect output for duplicate parameter names in non-strict scripts (e.g. `function (a, a) {}`).",
+        supersededBy: "rename-promise-executor-parameters-v2",
         evaluations: { "legacy:evaluation": { "evaluatedAt": "2026-01-25T20:08:45.593Z", "changedLines": 970, "durationSeconds": 0, "stableNames": 0, "diffSizePercent": 100 }, "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 100, "evaluatedAt": "2026-01-25T23:26:26.589Z", "changedLines": 970, "durationSeconds": 63.099434166, "stableNames": 1359 } },
     },
+    "rename-promise-executor-parameters-v2": {
+        recommended: true,
+        notes: "Supersedes rename-promise-executor-parameters with improved error-handler detection. Intentionally self-contained (helpers duplicated) per docs/workflow.md §3.6.",
+        evaluations: { "legacy:evaluation": { "diffSizePercent": 100, "evaluatedAt": "2026-01-25T21:22:01.643Z", "changedLines": 1086, "durationSeconds": 0, "stableNames": 0 }, "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 99.99622028196697, "evaluatedAt": "2026-01-26T07:04:42.067Z", "changedLines": 1086, "durationSeconds": 129.947271542, "stableNames": 1359 } },
+    },
     "rename-range-parameters": {
         recommended: true,
         notes: "Renames range-style parameters when the count defaults to the start value and start resets to 0.",
@@ -185,6 +191,11 @@ const manifestData = {
         notes: "Negative diff reduction in evaluation; keep optional.",
         evaluations: { "legacy:evaluation": { "diffSizePercent": 100.00188483649043, "evaluatedAt": "2026-01-25T10:04:22.417Z", "changedLines": 0, "durationSeconds": 0, "stableNames": 0 } },
     },
+    "rename-string-split-variables": {
+        recommended: true,
+        notes: "Measured with baseline none: 0.00%. Added to recommended for readability.",
+        evaluations: { "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 100, "evaluatedAt": "2026-01-27T06:41:49.624Z", "changedLines": 0, "durationSeconds": 149.03264720899998, "stableNames": 1357 } },
+    },
     "rename-this-aliases": {
         recommended: true,
         notes: "Measured with baseline none: 0.00%. Improves readability by stabilizing `this` aliases used for closures.",
@@ -236,7 +247,7 @@ const manifestData = {
     },
     "rename-use-reference-sets": {
         recommended: true,
-        evaluations: { "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 100, "evaluatedAt": "2026-01-26T08:03:28.285Z", "changedLines": 24, "durationSeconds": 146.202273464, "stableNames": 1358 } },
+        evaluations: { "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 100, "evaluatedAt": "2026-01-27T06:41:50.482Z", "changedLines": 24, "durationSeconds": 149.98115670800001, "stableNames": 1358 } },
     },
     "simplify-boolean-negations": {
         recommended: true,

package/dist/transforms/_generated/registry.js

@@ -31,11 +31,13 @@ import { renameParametersToMatchPropertiesTransform } from "../rename-parameters
 import { renameParametersToMatchPropertiesV2Transform } from "../rename-parameters-to-match-properties-v2/rename-parameters-to-match-properties-v2-transform.js";
 import { renameProcessStdoutHandlersTransform } from "../rename-process-stdout-handlers/rename-process-stdout-handlers-transform.js";
 import { renamePromiseExecutorParametersTransform } from "../rename-promise-executor-parameters/rename-promise-executor-parameters-transform.js";
+import { renamePromiseExecutorParametersV2Transform } from "../rename-promise-executor-parameters-v2/rename-promise-executor-parameters-v2-transform.js";
 import { renameRangeParametersTransform } from "../rename-range-parameters/rename-range-parameters-transform.js";
 import { renameRegexBuildersTransform } from "../rename-regex-builders/rename-regex-builders-transform.js";
 import { renameReplaceChildParametersTransform } from "../rename-replace-child-parameters/rename-replace-child-parameters-transform.js";
 import { renameRestParametersTransform } from "../rename-rest-parameters/rename-rest-parameters-transform.js";
 import { renameSafePropertyAccessorParametersTransform } from "../rename-safe-property-accessor-parameters/rename-safe-property-accessor-parameters-transform.js";
+import { renameStringSplitVariablesTransform } from "../rename-string-split-variables/rename-string-split-variables-transform.js";
 import { renameThisAliasesTransform } from "../rename-this-aliases/rename-this-aliases-transform.js";
 import { renameTimeoutDurationParametersTransform } from "../rename-timeout-duration-parameters/rename-timeout-duration-parameters-transform.js";
 import { renameTimeoutIdsTransform } from "../rename-timeout-ids/rename-timeout-ids-transform.js";
@@ -84,11 +86,13 @@ export const transformRegistry = {
     [renameParametersToMatchPropertiesV2Transform.id]: renameParametersToMatchPropertiesV2Transform,
     [renameProcessStdoutHandlersTransform.id]: renameProcessStdoutHandlersTransform,
     [renamePromiseExecutorParametersTransform.id]: renamePromiseExecutorParametersTransform,
+    [renamePromiseExecutorParametersV2Transform.id]: renamePromiseExecutorParametersV2Transform,
     [renameRangeParametersTransform.id]: renameRangeParametersTransform,
     [renameRegexBuildersTransform.id]: renameRegexBuildersTransform,
     [renameReplaceChildParametersTransform.id]: renameReplaceChildParametersTransform,
     [renameRestParametersTransform.id]: renameRestParametersTransform,
     [renameSafePropertyAccessorParametersTransform.id]: renameSafePropertyAccessorParametersTransform,
+    [renameStringSplitVariablesTransform.id]: renameStringSplitVariablesTransform,
     [renameThisAliasesTransform.id]: renameThisAliasesTransform,
     [renameTimeoutDurationParametersTransform.id]: renameTimeoutDurationParametersTransform,
     [renameTimeoutIdsTransform.id]: renameTimeoutIdsTransform,

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

@@ -3,9 +3,9 @@
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
             "diffSizePercent": 99.99244056393393,
-            "evaluatedAt": "2026-01-26T07:04:46.335Z",
+            "evaluatedAt": "2026-01-27T06:42:06.193Z",
             "changedLines": 602,
-            "durationSeconds": 121.114895708,
+            "durationSeconds": 165.514278459,
             "stableNames": 1358
         }
     },

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

@@ -1,5 +1,5 @@
 {
-    "recommended": true,
+    "recommended": false,
     "evaluations": {
         "legacy:evaluation": {
             "evaluatedAt": "2026-01-25T20:08:45.593Z",
@@ -16,5 +16,6 @@
             "stableNames": 1359
         }
     },
-    "notes": "Auto-added by evaluation script."
+    "notes": "Superseded by rename-promise-executor-parameters-v2. Known issue: can produce incorrect output for duplicate parameter names in non-strict scripts (e.g. `function (a, a) {}`).",
+    "supersededBy": "rename-promise-executor-parameters-v2"
 }

package/dist/transforms/rename-promise-executor-parameters-v2/is-valid-binding-identifier.d.ts

@@ -0,0 +1 @@
+export declare const isValidBindingIdentifier: (name: string) => boolean;

package/dist/transforms/rename-promise-executor-parameters-v2/is-valid-binding-identifier.js

@@ -0,0 +1,13 @@
+import { isIdentifierName, isKeyword, isStrictBindReservedWord, } from "@babel/helper-validator-identifier";
+export const isValidBindingIdentifier = (name) => {
+    if (!isIdentifierName(name))
+        return false;
+    if (isKeyword(name))
+        return false;
+    // Parse uses `sourceType: "unambiguous"` which often yields `script`; in that mode,
+    // some module-only reserved words (e.g. `await`) can be valid identifiers.
+    // When code is parsed as a module, invalid bindings are rejected by the parser anyway.
+    if (isStrictBindReservedWord(name, false))
+        return false;
+    return true;
+};

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

@@ -0,0 +1,20 @@
+{
+    "recommended": true,
+    "notes": "Supersedes rename-promise-executor-parameters with improved error-handler detection. Intentionally self-contained (helpers duplicated) per docs/workflow.md §3.6.",
+    "evaluations": {
+        "legacy:evaluation": {
+            "diffSizePercent": 100,
+            "evaluatedAt": "2026-01-25T21:22:01.643Z",
+            "changedLines": 1086,
+            "durationSeconds": 0,
+            "stableNames": 0
+        },
+        "claude-code-2.1.10:claude-code-2.1.11": {
+            "diffSizePercent": 99.99622028196697,
+            "evaluatedAt": "2026-01-26T07:04:42.067Z",
+            "changedLines": 1086,
+            "durationSeconds": 129.947271542,
+            "stableNames": 1359
+        }
+    }
+}

package/dist/transforms/rename-promise-executor-parameters-v2/promise-executor-heuristics.d.ts

@@ -0,0 +1,8 @@
+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 isDirectCallOfBinding: (referencePath: NodePath) => boolean;
+export declare const isAssignedToOnHandlerProperty: (referencePath: NodePath) => boolean;
+export declare const isErrorEventHandlerArgument: (referencePath: NodePath) => boolean;
+export declare const isErrorEventHandlerRemovalArgument: (referencePath: NodePath) => boolean;
+export declare const wouldShadowReferencedOuterBinding: (executorPath: NodePath<FunctionExpression | ArrowFunctionExpression>, targetName: string) => boolean;

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

@@ -0,0 +1,145 @@
+const allowedOnHandlerPropertyNames = new Set([
+    "onabort",
+    "onerror",
+    "ontimeout",
+]);
+const allowedErrorEventNames = new Set(["error"]);
+const allowedErrorListenerAddMethodNames = new Set([
+    "addListener",
+    "addEventListener",
+    "on",
+    "once",
+    "prependListener",
+    "prependOnceListener",
+]);
+const allowedErrorListenerRemoveMethodNames = new Set([
+    "off",
+    "removeEventListener",
+    "removeListener",
+]);
+export const getExecutorFunctionIfEligible = (path) => {
+    // Intentionally does NOT require the constructor callee to be `Promise`.
+    // Bundled/minified code frequently uses Promise polyfills like `new K((a,b)=>...)`,
+    // so we treat the executor signature + usage heuristics as the "promise-like" signal.
+    if (path.node.arguments.length !== 1)
+        return;
+    const executor = path.get("arguments.0");
+    if (!executor.isFunctionExpression() &&
+        !executor.isArrowFunctionExpression()) {
+        return;
+    }
+    const parameters = executor.node.params;
+    if (parameters.length !== 2)
+        return;
+    const [firstParameter, secondParameter] = parameters;
+    if (!firstParameter || !secondParameter)
+        return;
+    if (firstParameter.type !== "Identifier")
+        return;
+    if (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
+    // are already valid for that parsed sourceType (often `script` for minified bundles).
+    // We only validate that the *target* stable names are safe to introduce (see canRenameBindingSafely).
+    return executor;
+};
+export const isDirectCallOfBinding = (referencePath) => {
+    const parentPath = referencePath.parentPath;
+    if (!parentPath?.isCallExpression())
+        return false;
+    return referencePath.key === "callee";
+};
+export const isAssignedToOnHandlerProperty = (referencePath) => {
+    const parentPath = referencePath.parentPath;
+    if (!parentPath?.isAssignmentExpression())
+        return false;
+    if (parentPath.node.operator !== "=")
+        return false;
+    if (referencePath.key !== "right")
+        return false;
+    const left = parentPath.node.left;
+    if (left.type !== "MemberExpression")
+        return false;
+    if (left.computed)
+        return false;
+    if (left.property.type !== "Identifier")
+        return false;
+    if (!allowedOnHandlerPropertyNames.has(left.property.name))
+        return false;
+    return true;
+};
+export const isErrorEventHandlerArgument = (referencePath) => {
+    const parentPath = referencePath.parentPath;
+    if (!parentPath?.isCallExpression())
+        return false;
+    if (referencePath.listKey !== "arguments")
+        return false;
+    if (typeof referencePath.key !== "number")
+        return false;
+    if (referencePath.key !== 1)
+        return false;
+    const firstArgument = parentPath.node.arguments[0];
+    if (firstArgument?.type !== "StringLiteral")
+        return false;
+    if (!allowedErrorEventNames.has(firstArgument.value))
+        return false;
+    const callee = parentPath.node.callee;
+    if (callee.type !== "MemberExpression")
+        return false;
+    if (callee.computed)
+        return false;
+    if (callee.property.type !== "Identifier")
+        return false;
+    if (!allowedErrorListenerAddMethodNames.has(callee.property.name))
+        return false;
+    return true;
+};
+export const isErrorEventHandlerRemovalArgument = (referencePath) => {
+    const parentPath = referencePath.parentPath;
+    if (!parentPath?.isCallExpression())
+        return false;
+    if (referencePath.listKey !== "arguments")
+        return false;
+    if (typeof referencePath.key !== "number")
+        return false;
+    if (referencePath.key !== 1)
+        return false;
+    const firstArgument = parentPath.node.arguments[0];
+    if (firstArgument?.type !== "StringLiteral")
+        return false;
+    if (!allowedErrorEventNames.has(firstArgument.value))
+        return false;
+    const callee = parentPath.node.callee;
+    if (callee.type !== "MemberExpression")
+        return false;
+    if (callee.computed)
+        return false;
+    if (callee.property.type !== "Identifier")
+        return false;
+    if (!allowedErrorListenerRemoveMethodNames.has(callee.property.name)) {
+        return false;
+    }
+    return true;
+};
+export const wouldShadowReferencedOuterBinding = (executorPath, targetName) => {
+    const parentBinding = executorPath.scope.getBinding(targetName);
+    if (!parentBinding)
+        return false;
+    let foundReference = false;
+    executorPath.traverse({
+        Identifier(identifierPath) {
+            if (foundReference)
+                return;
+            if (identifierPath.node.name !== targetName)
+                return;
+            if (!identifierPath.isReferencedIdentifier())
+                return;
+            if (identifierPath.scope.getBinding(targetName) !== parentBinding)
+                return;
+            foundReference = true;
+            identifierPath.stop();
+        },
+    });
+    return foundReference;
+};

package/dist/transforms/rename-promise-executor-parameters-v2/rename-binding-if-safe.d.ts

@@ -0,0 +1,2 @@
+import type { NodePath } from "@babel/traverse";
+export declare const canRenameBindingSafely: (bindingScope: NodePath["scope"], fromName: string, toName: string) => boolean;

package/dist/transforms/rename-promise-executor-parameters-v2/rename-binding-if-safe.js

@@ -0,0 +1,43 @@
+import { isValidBindingIdentifier } from "./is-valid-binding-identifier.js";
+const hasIntermediateBinding = (fromScope, upToScope, targetName) => {
+    const visited = new Set();
+    let scope = fromScope;
+    while (scope && scope !== upToScope) {
+        // Cycles should never happen in Babel scope chains; if one does, be conservative and
+        // assume shadowing risk so we don't apply an unsafe rename.
+        if (visited.has(scope))
+            return true;
+        visited.add(scope);
+        if (scope.hasOwnBinding(targetName))
+            return true;
+        scope = scope.parent;
+    }
+    return false;
+};
+const hasShadowingRisk = (binding, bindingScope, targetName) => binding.referencePaths.some((referencePath) => {
+    if (referencePath.scope === bindingScope)
+        return false;
+    // Only consider bindings between this reference’s scope and the executor’s binding scope.
+    // This avoids incorrectly blocking safe renames due to unrelated outer bindings (e.g., an
+    // outer `resolve` that is never referenced inside the executor).
+    return hasIntermediateBinding(referencePath.scope, bindingScope, targetName);
+});
+export const canRenameBindingSafely = (bindingScope, fromName, toName) => {
+    if (fromName === toName)
+        return false;
+    if (!isValidBindingIdentifier(toName))
+        return false;
+    if (bindingScope.hasOwnBinding(toName))
+        return false;
+    const programScope = bindingScope.getProgramParent();
+    // `globals` contains only referenced (unbound) globals for this file, so this does not block
+    // in files where the identifier is never used.
+    if (Object.hasOwn(programScope.globals, toName))
+        return false;
+    const binding = bindingScope.getBinding(fromName);
+    if (!binding)
+        return false;
+    if (hasShadowingRisk(binding, bindingScope, toName))
+        return false;
+    return true;
+};

package/dist/transforms/rename-promise-executor-parameters-v2/rename-promise-executor-parameters-v2-transform.d.ts

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

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

@@ -0,0 +1,127 @@
+import { createRequire } from "node:module";
+import { isStableRenamed } from "../../core/stable-naming.js";
+import { getFilesToProcess, } from "../../core/types.js";
+import { getExecutorFunctionIfEligible, isAssignedToOnHandlerProperty, isDirectCallOfBinding, isErrorEventHandlerArgument, isErrorEventHandlerRemovalArgument, wouldShadowReferencedOuterBinding, } from "./promise-executor-heuristics.js";
+import { canRenameBindingSafely } from "./rename-binding-if-safe.js";
+const STABLE_PREFIX = "$";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const traverse = require("@babel/traverse").default;
+export const renamePromiseExecutorParametersV2Transform = {
+    id: "rename-promise-executor-parameters-v2",
+    description: "Renames promise-like executor parameters to $resolve/$reject when usage is high-confidence, including error event handlers",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const fileInfo of getFilesToProcess(context)) {
+            traverse(fileInfo.ast, {
+                NewExpression(path) {
+                    nodesVisited++;
+                    const executorPath = getExecutorFunctionIfEligible(path);
+                    if (!executorPath)
+                        return;
+                    // Redundant with getExecutorFunctionIfEligible's narrowing, but keeps this visitor robust
+                    // if eligibility rules ever change (and avoids relying on a tuple cast).
+                    const parameters = executorPath.node.params;
+                    if (parameters.length !== 2)
+                        return;
+                    const [firstParameter, secondParameter] = parameters;
+                    if (!firstParameter || !secondParameter)
+                        return;
+                    if (firstParameter.type !== "Identifier")
+                        return;
+                    if (secondParameter.type !== "Identifier")
+                        return;
+                    const resolveParameter = firstParameter;
+                    const rejectParameter = secondParameter;
+                    // 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)
+                        return;
+                    const targetResolveName = `${STABLE_PREFIX}resolve`;
+                    const targetRejectName = `${STABLE_PREFIX}reject`;
+                    // 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) &&
+                        rejectParameter.name !== targetRejectName) {
+                        return;
+                    }
+                    const bindingScope = executorPath.scope;
+                    const resolveBinding = bindingScope.getBinding(resolveParameter.name);
+                    const rejectBinding = bindingScope.getBinding(rejectParameter.name);
+                    if (!resolveBinding || !rejectBinding)
+                        return;
+                    const resolveIsCalled = resolveBinding.referencePaths.some((referencePath) => isDirectCallOfBinding(referencePath));
+                    if (!resolveIsCalled)
+                        return;
+                    const resolveIsOnlyCalled = resolveBinding.referencePaths.every((referencePath) => isDirectCallOfBinding(referencePath));
+                    // Intentionally does not accept `resolve` being passed as a callback (e.g. `on("end", resolve)`):
+                    // unlike `reject` as an `"error"` handler, those patterns are lower-confidence and easier to misclassify.
+                    if (!resolveIsOnlyCalled)
+                        return;
+                    const rejectIsCalled = rejectBinding.referencePaths.some((referencePath) => isDirectCallOfBinding(referencePath));
+                    const rejectIsOnHandler = rejectBinding.referencePaths.some((referencePath) => isAssignedToOnHandlerProperty(referencePath));
+                    const rejectIsErrorHandler = rejectBinding.referencePaths.some((referencePath) => isErrorEventHandlerArgument(referencePath));
+                    if (!rejectIsCalled && !rejectIsOnHandler && !rejectIsErrorHandler) {
+                        return;
+                    }
+                    const rejectIsOnlyCalledOrHandlerAssigned = rejectBinding.referencePaths.every((referencePath) => isDirectCallOfBinding(referencePath) ||
+                        isAssignedToOnHandlerProperty(referencePath) ||
+                        isErrorEventHandlerArgument(referencePath) ||
+                        isErrorEventHandlerRemovalArgument(referencePath));
+                    if (!rejectIsOnlyCalledOrHandlerAssigned)
+                        return;
+                    const wantsResolveRename = resolveParameter.name !== targetResolveName;
+                    const wantsRejectRename = rejectParameter.name !== targetRejectName;
+                    // Nothing to do: both parameters are already the stable target names.
+                    if (!wantsResolveRename && !wantsRejectRename)
+                        return;
+                    // Shadowing checks require a full traversal of the executor, so only do them for parameters
+                    // that actually need renaming.
+                    const resolveWouldShadow = wantsResolveRename &&
+                        wouldShadowReferencedOuterBinding(executorPath, targetResolveName);
+                    const rejectWouldShadow = wantsRejectRename &&
+                        wouldShadowReferencedOuterBinding(executorPath, targetRejectName);
+                    const fromResolveName = resolveParameter.name;
+                    const fromRejectName = rejectParameter.name;
+                    const canRenameResolve = !wantsResolveRename ||
+                        (!resolveWouldShadow &&
+                            canRenameBindingSafely(bindingScope, fromResolveName, targetResolveName));
+                    const canRenameReject = !wantsRejectRename ||
+                        (!rejectWouldShadow &&
+                            canRenameBindingSafely(bindingScope, fromRejectName, targetRejectName));
+                    // Avoid ending up with inconsistent executor signatures like `(WA, reject)` —
+                    // only rename when both parameters are already correct or can be renamed safely.
+                    if (!canRenameResolve || !canRenameReject)
+                        return;
+                    let renamedResolve = false;
+                    let renamedReject = false;
+                    // We already validated both renames against the same pre-rename scope state, so we can
+                    // rename directly without re-checking and risking a partial rename.
+                    //
+                    // Note: Renaming `resolve` first cannot invalidate `reject`'s rename because:
+                    // - we reject duplicate parameter names (`resolveParameter.name === rejectParameter.name`), and
+                    // - we never allow a stable-but-wrong name like `$resolve`/`$reject` in the opposite slot.
+                    if (wantsResolveRename) {
+                        bindingScope.rename(fromResolveName, targetResolveName);
+                        renamedResolve = true;
+                    }
+                    if (wantsRejectRename) {
+                        bindingScope.rename(fromRejectName, targetRejectName);
+                        renamedReject = true;
+                    }
+                    // Metrics represent renamed bindings, not "executors processed".
+                    transformationsApplied +=
+                        Number(renamedResolve) + Number(renamedReject);
+                },
+            });
+        }
+        return Promise.resolve({ nodesVisited, transformationsApplied });
+    },
+};

package/dist/transforms/rename-string-split-variables/get-split-helper-info.d.ts

@@ -0,0 +1,8 @@
+import type { ArrowFunctionExpression, FunctionDeclaration, FunctionExpression } from "@babel/types";
+import type { SplitHelperDeclarations } from "./split-helper-declarations.js";
+type SplitHelperInfo = SplitHelperDeclarations & {
+    inputName: string;
+    delimiterName: string;
+};
+export declare const getSplitHelperInfo: (node: FunctionDeclaration | FunctionExpression | ArrowFunctionExpression) => SplitHelperInfo | undefined;
+export {};

package/dist/transforms/rename-string-split-variables/get-split-helper-info.js

@@ -0,0 +1,40 @@
+import { isIdentifierNode } from "./split-helper-guards.js";
+import { getSplitHelperDeclarationsFromStatements } from "./split-helper-declarations.js";
+import { isSplitHelperLoop } from "./split-helper-loop.js";
+import { isSplitHelperTail } from "./split-helper-tail.js";
+export const getSplitHelperInfo = (node) => {
+    if (node.params.length !== 2)
+        return undefined;
+    const inputParameter = node.params[0];
+    const delimiterParameter = node.params[1];
+    if (!isIdentifierNode(inputParameter) ||
+        !isIdentifierNode(delimiterParameter))
+        return undefined;
+    if (node.body.type !== "BlockStatement")
+        return undefined;
+    const statements = node.body.body;
+    const declarationsMatch = getSplitHelperDeclarationsFromStatements(statements, inputParameter.name, delimiterParameter.name);
+    if (!declarationsMatch)
+        return undefined;
+    const { nextStatementIndex, ...declarations } = declarationsMatch;
+    const loopStatement = statements[nextStatementIndex];
+    if (!isSplitHelperLoop(loopStatement, declarations, inputParameter.name, delimiterParameter.name))
+        return undefined;
+    const tailStatements = statements.slice(nextStatementIndex + 1);
+    if (!isSplitHelperTail(tailStatements, declarations, inputParameter.name))
+        return undefined;
+    const uniqueNames = new Set([
+        inputParameter.name,
+        delimiterParameter.name,
+        declarations.partsName,
+        declarations.startIndexName,
+        declarations.delimiterIndexName,
+    ]);
+    if (uniqueNames.size !== 5)
+        return undefined;
+    return {
+        inputName: inputParameter.name,
+        delimiterName: delimiterParameter.name,
+        ...declarations,
+    };
+};

package/dist/transforms/rename-string-split-variables/manifest.json

@@ -0,0 +1,13 @@
+{
+    "recommended": true,
+    "evaluations": {
+        "claude-code-2.1.10:claude-code-2.1.11": {
+            "diffSizePercent": 100,
+            "evaluatedAt": "2026-01-27T06:41:49.624Z",
+            "changedLines": 0,
+            "durationSeconds": 149.03264720899998,
+            "stableNames": 1357
+        }
+    },
+    "notes": "Measured with baseline none: 0.00%. Added to recommended for readability."
+}

package/dist/transforms/rename-string-split-variables/rename-string-split-variables-transform.d.ts

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

package/dist/transforms/rename-string-split-variables/rename-string-split-variables-transform.js

@@ -0,0 +1,69 @@
+import { createRequire } from "node:module";
+import { RenameGroup } from "../../core/stable-naming.js";
+import { getFilesToProcess } from "../../core/types.js";
+import { getSplitHelperInfo } from "./get-split-helper-info.js";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const traverse = require("@babel/traverse").default;
+const collectSplitHelperRenames = (path, group) => {
+    // Intentionally no early-return based on stable-renamed params:
+    // parameters can be stable while helper locals are still minified.
+    const info = getSplitHelperInfo(path.node);
+    if (!info)
+        return;
+    const scope = path.scope;
+    group.add({
+        scope,
+        currentName: info.inputName,
+        baseName: "input",
+    });
+    group.add({
+        scope,
+        currentName: info.delimiterName,
+        baseName: "delimiter",
+    });
+    group.add({
+        scope,
+        currentName: info.partsName,
+        baseName: "parts",
+    });
+    group.add({
+        scope,
+        currentName: info.startIndexName,
+        baseName: "startIndex",
+    });
+    group.add({
+        scope,
+        currentName: info.delimiterIndexName,
+        baseName: "delimiterIndex",
+    });
+};
+export const renameStringSplitVariablesTransform = {
+    id: "rename-string-split-variables",
+    description: "Renames local variables in manual string split helpers (indexOf + slice loop) to stable $input-style names (prefers $input/$delimiter/$parts/$startIndex/$delimiterIndex)",
+    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, {
+                FunctionDeclaration(path) {
+                    nodesVisited++;
+                    collectSplitHelperRenames(path, group);
+                },
+                FunctionExpression(path) {
+                    nodesVisited++;
+                    collectSplitHelperRenames(path, group);
+                },
+                ArrowFunctionExpression(path) {
+                    nodesVisited++;
+                    collectSplitHelperRenames(path, group);
+                },
+            });
+            transformationsApplied += group.apply();
+        }
+        return Promise.resolve({ nodesVisited, transformationsApplied });
+    },
+};

package/dist/transforms/rename-string-split-variables/split-helper-declarations.d.ts

@@ -0,0 +1,11 @@
+import type { Statement } from "@babel/types";
+export type SplitHelperDeclarations = {
+    partsName: string;
+    startIndexName: string;
+    delimiterIndexName: string;
+};
+type SplitHelperDeclarationsMatch = SplitHelperDeclarations & {
+    nextStatementIndex: number;
+};
+export declare const getSplitHelperDeclarationsFromStatements: (statements: Statement[], inputName: string, delimiterName: string) => SplitHelperDeclarationsMatch | undefined;
+export {};

package/dist/transforms/rename-string-split-variables/split-helper-declarations.js

@@ -0,0 +1,80 @@
+import { isIdentifierNode, isMemberCall, isNumericLiteralNode, } from "./split-helper-guards.js";
+const isDirectivePrologueStatement = (statement) => {
+    // In JavaScript, any leading sequence of `"..."`; expression statements is the
+    // "directive prologue" (most commonly `"use strict";`). Babel sometimes also
+    // marks these with `statement.directive`, but we intentionally only rely on
+    // the lexical shape so we still match after AST rewrites.
+    if (statement.type !== "ExpressionStatement")
+        return false;
+    return statement.expression.type === "StringLiteral";
+};
+const getVariableDeclarators = (statement) => {
+    if (statement.type !== "VariableDeclaration")
+        return undefined;
+    if (statement.declarations.length === 0)
+        return undefined;
+    return statement.declarations;
+};
+export const getSplitHelperDeclarationsFromStatements = (statements, inputName, delimiterName) => {
+    const declarators = [];
+    let statementIndex = 0;
+    while (statementIndex < statements.length) {
+        const statement = statements[statementIndex];
+        if (!statement)
+            return undefined;
+        if (!isDirectivePrologueStatement(statement))
+            break;
+        statementIndex++;
+    }
+    if (statementIndex >= statements.length)
+        return undefined;
+    let declarationStatementsConsumed = 0;
+    while (declarators.length < 3) {
+        if (statementIndex >= statements.length)
+            return undefined;
+        const statement = statements[statementIndex];
+        if (!statement)
+            return undefined;
+        const statementDeclarators = getVariableDeclarators(statement);
+        if (!statementDeclarators)
+            return undefined;
+        declarationStatementsConsumed++;
+        if (declarationStatementsConsumed > 3)
+            return undefined;
+        const totalDeclarators = declarators.length + statementDeclarators.length;
+        if (totalDeclarators > 3)
+            return undefined;
+        declarators.push(...statementDeclarators);
+        statementIndex++;
+    }
+    const identifierDeclarators = declarators.filter((declarator) => declarator.id.type === "Identifier");
+    if (identifierDeclarators.length !== declarators.length)
+        return undefined;
+    const partsDeclarator = identifierDeclarators.find((declarator) => {
+        if (declarator.init?.type !== "ArrayExpression")
+            return false;
+        return declarator.init.elements.length === 0;
+    });
+    const startDeclarator = identifierDeclarators.find((declarator) => isNumericLiteralNode(declarator.init ?? undefined, 0));
+    const indexDeclarator = identifierDeclarators.find((declarator) => {
+        if (declarator.init?.type !== "CallExpression")
+            return false;
+        if (!isMemberCall(declarator.init, inputName, "indexOf"))
+            return false;
+        if (!isIdentifierNode(declarator.init.arguments[0], delimiterName))
+            return false;
+        if (declarator.init.arguments.length === 1)
+            return true;
+        if (declarator.init.arguments.length !== 2)
+            return false;
+        return isNumericLiteralNode(declarator.init.arguments[1], 0);
+    });
+    if (!partsDeclarator || !startDeclarator || !indexDeclarator)
+        return undefined;
+    return {
+        partsName: partsDeclarator.id.name,
+        startIndexName: startDeclarator.id.name,
+        delimiterIndexName: indexDeclarator.id.name,
+        nextStatementIndex: statementIndex,
+    };
+};

package/dist/transforms/rename-string-split-variables/split-helper-guards.d.ts

@@ -0,0 +1,8 @@
+import type { BinaryExpression, CallExpression, Identifier, Node, NumericLiteral, Statement } from "@babel/types";
+export declare const isIdentifierNode: (node: Node | undefined, name?: string) => node is Identifier;
+export declare const isNumericLiteralNode: (node: Node | undefined, value?: number) => node is NumericLiteral;
+export declare const getBlockStatements: (statement: Statement) => Statement[] | undefined;
+export declare const isMemberCall: (expression: CallExpression, objectName: string, propertyName: string) => boolean;
+export declare const isPushSliceStatement: (statement: Statement, partsName: string, inputName: string, startName: string, endName?: string) => boolean;
+export declare const isAssignmentStatement: (statement: Statement, targetName: string, expectedExpression: (expression: Node) => boolean) => boolean;
+export declare const isBinaryExpression: (expression: Node, operator: BinaryExpression["operator"], leftName: string, rightValue: number) => boolean;

package/dist/transforms/rename-string-split-variables/split-helper-guards.js

@@ -0,0 +1,73 @@
+export const isIdentifierNode = (node, name) => {
+    if (node?.type !== "Identifier")
+        return false;
+    return name ? node.name === name : true;
+};
+export const isNumericLiteralNode = (node, value) => {
+    if (node?.type !== "NumericLiteral")
+        return false;
+    return value === undefined ? true : node.value === value;
+};
+export const getBlockStatements = (statement) => {
+    if (statement.type !== "BlockStatement")
+        return undefined;
+    return statement.body;
+};
+export const isMemberCall = (expression, objectName, propertyName) => {
+    const callee = expression.callee;
+    if (callee.type !== "MemberExpression")
+        return false;
+    if (callee.computed)
+        return false;
+    if (!isIdentifierNode(callee.object, objectName))
+        return false;
+    return isIdentifierNode(callee.property, propertyName);
+};
+const isSliceCallWithArguments = (expression, inputName, startName, endName) => {
+    if (!isMemberCall(expression, inputName, "slice"))
+        return false;
+    if (!isIdentifierNode(expression.arguments[0], startName))
+        return false;
+    if (endName === undefined) {
+        return expression.arguments.length === 1;
+    }
+    if (!isIdentifierNode(expression.arguments[1], endName))
+        return false;
+    return expression.arguments.length === 2;
+};
+export const isPushSliceStatement = (statement, partsName, inputName, startName, endName) => {
+    if (statement.type !== "ExpressionStatement")
+        return false;
+    const expression = statement.expression;
+    if (expression.type !== "CallExpression")
+        return false;
+    if (!isMemberCall(expression, partsName, "push"))
+        return false;
+    if (expression.arguments.length !== 1)
+        return false;
+    const argument0 = expression.arguments[0];
+    if (argument0?.type !== "CallExpression")
+        return false;
+    return isSliceCallWithArguments(argument0, inputName, startName, endName);
+};
+export const isAssignmentStatement = (statement, targetName, expectedExpression) => {
+    if (statement.type !== "ExpressionStatement")
+        return false;
+    const expression = statement.expression;
+    if (expression.type !== "AssignmentExpression")
+        return false;
+    if (expression.operator !== "=")
+        return false;
+    if (!isIdentifierNode(expression.left, targetName))
+        return false;
+    return expectedExpression(expression.right);
+};
+export const isBinaryExpression = (expression, operator, leftName, rightValue) => {
+    if (expression.type !== "BinaryExpression")
+        return false;
+    if (expression.operator !== operator)
+        return false;
+    if (!isIdentifierNode(expression.left, leftName))
+        return false;
+    return isNumericLiteralNode(expression.right, rightValue);
+};

package/dist/transforms/rename-string-split-variables/split-helper-loop.d.ts

@@ -0,0 +1,3 @@
+import type { Statement } from "@babel/types";
+import type { SplitHelperDeclarations } from "./split-helper-declarations.js";
+export declare const isSplitHelperLoop: (statement: Statement | undefined, declarations: SplitHelperDeclarations, inputName: string, delimiterName: string) => boolean;

package/dist/transforms/rename-string-split-variables/split-helper-loop.js

@@ -0,0 +1,116 @@
+import { isAssignmentStatement, isBinaryExpression, isIdentifierNode, isMemberCall, isNumericLiteralNode, isPushSliceStatement, } from "./split-helper-guards.js";
+const isNegativeOneLiteral = (expression) => {
+    if (expression.type === "NumericLiteral")
+        return expression.value === -1;
+    if (expression.type !== "UnaryExpression")
+        return false;
+    if (expression.operator !== "-")
+        return false;
+    if (expression.argument.type !== "NumericLiteral")
+        return false;
+    return expression.argument.value === 1;
+};
+const isNotFoundBinaryTest = (expression, name) => {
+    if (expression.type !== "BinaryExpression")
+        return false;
+    if (expression.operator !== "!==" && expression.operator !== "!=")
+        return false;
+    if (!isIdentifierNode(expression.left, name))
+        return false;
+    return isNegativeOneLiteral(expression.right);
+};
+const isFoundBinaryTest = (expression, name) => {
+    if (expression.type !== "BinaryExpression")
+        return false;
+    if (expression.operator !== ">")
+        return false;
+    if (!isIdentifierNode(expression.left, name))
+        return false;
+    return isNegativeOneLiteral(expression.right);
+};
+const isBitwiseNotTest = (expression, name) => {
+    if (expression.type !== "UnaryExpression")
+        return false;
+    if (expression.operator !== "~")
+        return false;
+    return isIdentifierNode(expression.argument, name);
+};
+export const isSplitHelperLoop = (statement, declarations, inputName, delimiterName) => {
+    if (statement?.type !== "WhileStatement")
+        return false;
+    const isNonNegativeTest = (expression) => {
+        if (isBinaryExpression(expression, ">=", declarations.delimiterIndexName, 0)) {
+            return true;
+        }
+        if (expression.type !== "BinaryExpression")
+            return false;
+        if (expression.operator !== "<=")
+            return false;
+        if (!isNumericLiteralNode(expression.left, 0))
+            return false;
+        return isIdentifierNode(expression.right, declarations.delimiterIndexName);
+    };
+    if (!isNonNegativeTest(statement.test) &&
+        !isNotFoundBinaryTest(statement.test, declarations.delimiterIndexName) &&
+        !isFoundBinaryTest(statement.test, declarations.delimiterIndexName) &&
+        !isBitwiseNotTest(statement.test, declarations.delimiterIndexName)) {
+        return false;
+    }
+    if (statement.body.type !== "BlockStatement")
+        return false;
+    if (statement.body.body.length !== 3)
+        return false;
+    const [pushStatement, advanceStatement, updateStatement] = statement.body.body;
+    if (!pushStatement || !advanceStatement || !updateStatement)
+        return false;
+    if (!isPushSliceStatement(pushStatement, declarations.partsName, inputName, declarations.startIndexName, declarations.delimiterIndexName))
+        return false;
+    const isAdvanceExpression = (expression) => {
+        if (isBinaryExpression(expression, "+", declarations.delimiterIndexName, 1)) {
+            return true;
+        }
+        if (expression.type === "BinaryExpression" && expression.operator === "+") {
+            if (isNumericLiteralNode(expression.left, 1) &&
+                isIdentifierNode(expression.right, declarations.delimiterIndexName)) {
+                return true;
+            }
+            const left = expression.left;
+            const right = expression.right;
+            if (left.type === "MemberExpression" &&
+                !left.computed &&
+                isIdentifierNode(left.object, delimiterName) &&
+                isIdentifierNode(left.property, "length") &&
+                isIdentifierNode(right, declarations.delimiterIndexName)) {
+                return true;
+            }
+        }
+        if (expression.type !== "BinaryExpression")
+            return false;
+        if (expression.operator !== "+")
+            return false;
+        if (!isIdentifierNode(expression.left, declarations.delimiterIndexName))
+            return false;
+        const right = expression.right;
+        if (right.type !== "MemberExpression")
+            return false;
+        if (right.computed)
+            return false;
+        if (!isIdentifierNode(right.object, delimiterName))
+            return false;
+        return isIdentifierNode(right.property, "length");
+    };
+    if (!isAssignmentStatement(advanceStatement, declarations.startIndexName, isAdvanceExpression))
+        return false;
+    const isUpdateExpression = (expression) => {
+        if (expression.type !== "CallExpression")
+            return false;
+        if (!isMemberCall(expression, inputName, "indexOf"))
+            return false;
+        if (expression.arguments.length !== 2)
+            return false;
+        if (!isIdentifierNode(expression.arguments[0], delimiterName))
+            return false;
+        return isIdentifierNode(expression.arguments[1], declarations.startIndexName);
+    };
+    return isAssignmentStatement(updateStatement, declarations.delimiterIndexName, isUpdateExpression);
+};

package/dist/transforms/rename-string-split-variables/split-helper-tail-expressions.d.ts

@@ -0,0 +1,3 @@
+import type { Node } from "@babel/types";
+import type { SplitHelperDeclarations } from "./split-helper-declarations.js";
+export declare const isReturnWithOptionalTailPush: (node: Node, declarations: SplitHelperDeclarations, inputName: string) => boolean;

package/dist/transforms/rename-string-split-variables/split-helper-tail-expressions.js

@@ -0,0 +1,86 @@
+import { isIdentifierNode } from "./split-helper-guards.js";
+import { isAtEndTest, isShouldPushTailTest, } from "./split-helper-tail-tests.js";
+const isPushSliceCallExpression = (node, declarations, inputName) => {
+    if (node.type !== "CallExpression")
+        return false;
+    const callee = node.callee;
+    if (callee.type !== "MemberExpression")
+        return false;
+    if (callee.computed)
+        return false;
+    if (!isIdentifierNode(callee.object, declarations.partsName))
+        return false;
+    if (!isIdentifierNode(callee.property, "push"))
+        return false;
+    if (node.arguments.length !== 1)
+        return false;
+    const argument0 = node.arguments[0];
+    if (argument0?.type !== "CallExpression")
+        return false;
+    const sliceCallee = argument0.callee;
+    if (sliceCallee.type !== "MemberExpression")
+        return false;
+    if (sliceCallee.computed)
+        return false;
+    if (!isIdentifierNode(sliceCallee.object, inputName))
+        return false;
+    if (!isIdentifierNode(sliceCallee.property, "slice"))
+        return false;
+    if (argument0.arguments.length !== 1)
+        return false;
+    return isIdentifierNode(argument0.arguments[0], declarations.startIndexName);
+};
+const isPushSequenceExpression = (node, declarations, inputName) => {
+    if (node.type !== "SequenceExpression")
+        return false;
+    if (node.expressions.length !== 2)
+        return false;
+    const [first, second] = node.expressions;
+    if (!first || !second)
+        return false;
+    if (!isPushSliceCallExpression(first, declarations, inputName))
+        return false;
+    return isIdentifierNode(second, declarations.partsName);
+};
+export const isReturnWithOptionalTailPush = (node, declarations, inputName) => {
+    if (node.type === "ConditionalExpression") {
+        const testIsShouldPush = isShouldPushTailTest(node.test, declarations, inputName);
+        const testIsAtEnd = isAtEndTest(node.test, declarations, inputName);
+        if (!testIsShouldPush && !testIsAtEnd)
+            return false;
+        const consequent = node.consequent;
+        const alternate = node.alternate;
+        const consequentIsParts = isIdentifierNode(consequent, declarations.partsName);
+        const alternateIsParts = isIdentifierNode(alternate, declarations.partsName);
+        const consequentIsPush = isPushSequenceExpression(consequent, declarations, inputName);
+        const alternateIsPush = isPushSequenceExpression(alternate, declarations, inputName);
+        if (testIsShouldPush) {
+            if (!consequentIsPush)
+                return false;
+            return alternateIsParts;
+        }
+        if (!testIsAtEnd)
+            return false;
+        if (!alternateIsPush)
+            return false;
+        return consequentIsParts;
+    }
+    if (node.type !== "SequenceExpression")
+        return false;
+    if (node.expressions.length !== 2)
+        return false;
+    const [first, second] = node.expressions;
+    if (!first || !second)
+        return false;
+    if (!isIdentifierNode(second, declarations.partsName))
+        return false;
+    if (isPushSliceCallExpression(first, declarations, inputName))
+        return true;
+    if (first.type === "LogicalExpression" &&
+        first.operator === "&&" &&
+        isShouldPushTailTest(first.left, declarations, inputName) &&
+        isPushSliceCallExpression(first.right, declarations, inputName)) {
+        return true;
+    }
+    return false;
+};

package/dist/transforms/rename-string-split-variables/split-helper-tail-tests.d.ts

@@ -0,0 +1,4 @@
+import type { Node } from "@babel/types";
+import type { SplitHelperDeclarations } from "./split-helper-declarations.js";
+export declare const isShouldPushTailTest: (node: Node, declarations: SplitHelperDeclarations, inputName: string) => boolean;
+export declare const isAtEndTest: (node: Node, declarations: SplitHelperDeclarations, inputName: string) => boolean;

package/dist/transforms/rename-string-split-variables/split-helper-tail-tests.js

@@ -0,0 +1,39 @@
+import { isIdentifierNode } from "./split-helper-guards.js";
+const isInputLengthMemberExpression = (node, inputName) => {
+    if (node.type !== "MemberExpression")
+        return false;
+    if (node.computed)
+        return false;
+    if (!isIdentifierNode(node.object, inputName))
+        return false;
+    return isIdentifierNode(node.property, "length");
+};
+export const isShouldPushTailTest = (node, declarations, inputName) => {
+    if (node.type !== "BinaryExpression")
+        return false;
+    const operator = node.operator;
+    if ((operator === "!==" || operator === "!=" || operator === "<") &&
+        isIdentifierNode(node.left, declarations.startIndexName) &&
+        isInputLengthMemberExpression(node.right, inputName)) {
+        return true;
+    }
+    if ((operator === "!==" || operator === "!=" || operator === ">") &&
+        isInputLengthMemberExpression(node.left, inputName) &&
+        isIdentifierNode(node.right, declarations.startIndexName)) {
+        return true;
+    }
+    return false;
+};
+export const isAtEndTest = (node, declarations, inputName) => {
+    if (node.type !== "BinaryExpression")
+        return false;
+    const operator = node.operator;
+    if (operator !== "===" && operator !== "==")
+        return false;
+    if (isIdentifierNode(node.left, declarations.startIndexName) &&
+        isInputLengthMemberExpression(node.right, inputName)) {
+        return true;
+    }
+    return (isInputLengthMemberExpression(node.left, inputName) &&
+        isIdentifierNode(node.right, declarations.startIndexName));
+};

package/dist/transforms/rename-string-split-variables/split-helper-tail.d.ts

@@ -0,0 +1,3 @@
+import type { Statement } from "@babel/types";
+import type { SplitHelperDeclarations } from "./split-helper-declarations.js";
+export declare const isSplitHelperTail: (tailStatements: Statement[], declarations: SplitHelperDeclarations, inputName: string) => boolean;

package/dist/transforms/rename-string-split-variables/split-helper-tail.js

@@ -0,0 +1,49 @@
+import { getBlockStatements, isIdentifierNode, isPushSliceStatement, } from "./split-helper-guards.js";
+import { isReturnWithOptionalTailPush } from "./split-helper-tail-expressions.js";
+import { isShouldPushTailTest } from "./split-helper-tail-tests.js";
+const isReturnPartsStatement = (statement, declarations) => {
+    if (statement?.type !== "ReturnStatement")
+        return false;
+    return isIdentifierNode(statement.argument ?? undefined, declarations.partsName);
+};
+export const isSplitHelperTail = (tailStatements, declarations, inputName) => {
+    if (tailStatements.length === 2) {
+        const [firstTailStatement, secondTailStatement] = tailStatements;
+        if (!firstTailStatement || !secondTailStatement)
+            return false;
+        if (firstTailStatement.type === "IfStatement") {
+            const ifStatement = firstTailStatement;
+            const returnStatement = secondTailStatement;
+            if (ifStatement.alternate)
+                return false;
+            if (!isShouldPushTailTest(ifStatement.test, declarations, inputName))
+                return false;
+            const ifStatements = getBlockStatements(ifStatement.consequent) ?? [
+                ifStatement.consequent,
+            ];
+            if (ifStatements.length !== 1)
+                return false;
+            const ifConsequent = ifStatements[0];
+            if (!ifConsequent)
+                return false;
+            if (!isPushSliceStatement(ifConsequent, declarations.partsName, inputName, declarations.startIndexName))
+                return false;
+            return isReturnPartsStatement(returnStatement, declarations);
+        }
+        if (isPushSliceStatement(firstTailStatement, declarations.partsName, inputName, declarations.startIndexName)) {
+            return isReturnPartsStatement(secondTailStatement, declarations);
+        }
+        return false;
+    }
+    if (tailStatements.length !== 1)
+        return false;
+    const tailStatement = tailStatements[0];
+    if (!tailStatement)
+        return false;
+    if (tailStatement.type !== "ReturnStatement")
+        return false;
+    const argument = tailStatement.argument;
+    if (!argument)
+        return false;
+    return isReturnWithOptionalTailPush(argument, declarations, inputName);
+};

package/dist/transforms/rename-use-reference-sets/manifest.json

@@ -3,9 +3,9 @@
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
             "diffSizePercent": 100,
-            "evaluatedAt": "2026-01-26T08:03:28.285Z",
+            "evaluatedAt": "2026-01-27T06:41:50.482Z",
             "changedLines": 24,
-            "durationSeconds": 146.202273464,
+            "durationSeconds": 149.98115670800001,
             "stableNames": 1358
         }
     }

package/package.json

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