miniread 1.111.0 → 1.112.0

package/dist/transforms/_generated/catalog.js

@@ -38,10 +38,14 @@ import { renameClientAliasesTransform } from "../../transforms-by-id/rename-clie
 import renameClientAliasesManifest from "../../transforms-by-id/rename-client-aliases/manifest.json" with { type: "json" };
 import { renameCollectionConstructorVariablesTransform } from "../../transforms-by-id/rename-collection-constructor-variables/rename-collection-constructor-variables-transform.js";
 import renameCollectionConstructorVariablesManifest from "../../transforms-by-id/rename-collection-constructor-variables/manifest.json" with { type: "json" };
+import { renameCommandResultVariablesTransform } from "../../transforms-by-id/rename-command-result-variables/rename-command-result-variables-transform.js";
+import renameCommandResultVariablesManifest from "../../transforms-by-id/rename-command-result-variables/manifest.json" with { type: "json" };
 import { renameComparisonFlagsTransform } from "../../transforms-by-id/rename-comparison-flags/rename-comparison-flags-transform.js";
 import renameComparisonFlagsManifest from "../../transforms-by-id/rename-comparison-flags/manifest.json" with { type: "json" };
 import { renameComparisonFlagsV2Transform } from "../../transforms-by-id/rename-comparison-flags-v2/rename-comparison-flags-v2-transform.js";
 import renameComparisonFlagsV2Manifest from "../../transforms-by-id/rename-comparison-flags-v2/manifest.json" with { type: "json" };
+import { renameConstructorVariablesTransform } from "../../transforms-by-id/rename-constructor-variables/rename-constructor-variables-transform.js";
+import renameConstructorVariablesManifest from "../../transforms-by-id/rename-constructor-variables/manifest.json" with { type: "json" };
 import { renameDateNowStartTimesTransform } from "../../transforms-by-id/rename-date-now-start-times/rename-date-now-start-times-transform.js";
 import renameDateNowStartTimesManifest from "../../transforms-by-id/rename-date-now-start-times/manifest.json" with { type: "json" };
 import { renameDefaultOptionsParametersV3Transform } from "../../transforms-by-id/rename-default-options-parameters-v3/rename-default-options-parameters-v3-transform.js";
@@ -132,10 +136,10 @@ import { renameReturnObjectBindingsTransform } from "../../transforms-by-id/rena
 import renameReturnObjectBindingsManifest from "../../transforms-by-id/rename-return-object-bindings/manifest.json" with { type: "json" };
 import { renameSanitizedStringVariablesTransform } from "../../transforms-by-id/rename-sanitized-string-variables/rename-sanitized-string-variables-transform.js";
 import renameSanitizedStringVariablesManifest from "../../transforms-by-id/rename-sanitized-string-variables/manifest.json" with { type: "json" };
-import { renameSearchParametersVariablesTransform } from "../../transforms-by-id/rename-search-parameters-variables/rename-search-parameters-variables-transform.js";
-import renameSearchParametersVariablesManifest from "../../transforms-by-id/rename-search-parameters-variables/manifest.json" with { type: "json" };
 import { renameSetstateUpdaterParametersTransform } from "../../transforms-by-id/rename-setstate-updater-parameters/rename-setstate-updater-parameters-transform.js";
 import renameSetstateUpdaterParametersManifest from "../../transforms-by-id/rename-setstate-updater-parameters/manifest.json" with { type: "json" };
+import { renameStreamDataChunksTransform } from "../../transforms-by-id/rename-stream-data-chunks/rename-stream-data-chunks-transform.js";
+import renameStreamDataChunksManifest from "../../transforms-by-id/rename-stream-data-chunks/manifest.json" with { type: "json" };
 import { renameStringSplitVariablesV2Transform } from "../../transforms-by-id/rename-string-split-variables-v2/rename-string-split-variables-v2-transform.js";
 import renameStringSplitVariablesV2Manifest from "../../transforms-by-id/rename-string-split-variables-v2/manifest.json" with { type: "json" };
 import { renameThisAliasesTransform } from "../../transforms-by-id/rename-this-aliases/rename-this-aliases-transform.js";
@@ -286,6 +290,11 @@ export const generatedTransformCatalog = [
         transform: renameCollectionConstructorVariablesTransform,
         manifest: renameCollectionConstructorVariablesManifest,
     },
+    {
+        id: renameCommandResultVariablesTransform.id,
+        transform: renameCommandResultVariablesTransform,
+        manifest: renameCommandResultVariablesManifest,
+    },
     {
         id: renameComparisonFlagsTransform.id,
         transform: renameComparisonFlagsTransform,
@@ -296,6 +305,11 @@ export const generatedTransformCatalog = [
         transform: renameComparisonFlagsV2Transform,
         manifest: renameComparisonFlagsV2Manifest,
     },
+    {
+        id: renameConstructorVariablesTransform.id,
+        transform: renameConstructorVariablesTransform,
+        manifest: renameConstructorVariablesManifest,
+    },
     {
         id: renameDateNowStartTimesTransform.id,
         transform: renameDateNowStartTimesTransform,
@@ -521,16 +535,16 @@ export const generatedTransformCatalog = [
         transform: renameSanitizedStringVariablesTransform,
         manifest: renameSanitizedStringVariablesManifest,
     },
-    {
-        id: renameSearchParametersVariablesTransform.id,
-        transform: renameSearchParametersVariablesTransform,
-        manifest: renameSearchParametersVariablesManifest,
-    },
     {
         id: renameSetstateUpdaterParametersTransform.id,
         transform: renameSetstateUpdaterParametersTransform,
         manifest: renameSetstateUpdaterParametersManifest,
     },
+    {
+        id: renameStreamDataChunksTransform.id,
+        transform: renameStreamDataChunksTransform,
+        manifest: renameStreamDataChunksManifest,
+    },
     {
         id: renameStringSplitVariablesV2Transform.id,
         transform: renameStringSplitVariablesV2Transform,

package/dist/transforms-by-id/rename-collection-constructor-variables/manifest.json

@@ -1,5 +1,6 @@
 {
-    "notes": "Renames variables initialized with collection constructors (Set, Map, WeakSet, WeakMap) to stable semantic names.",
+    "notes": "Superseded by rename-constructor-variables for constructor-derived variable naming coverage.",
+    "supersededBy": "rename-constructor-variables",
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
             "diffSizePercent": 99.96976225573572,
@@ -9,6 +10,5 @@
             "stableNames": 1364
         }
     },
-    "recommended": true,
-    "recommendedOrder": 101
+    "recommended": false
 }

package/dist/transforms-by-id/rename-command-result-variables/manifest.json

@@ -0,0 +1,13 @@
+{
+    "evaluations": {
+        "claude-code-2.1.10:claude-code-2.1.11": {
+            "diffSizePercent": 100,
+            "evaluatedAt": "2026-02-13T08:14:27.481Z",
+            "changedLines": 338,
+            "durationSeconds": 39.400678667,
+            "stableNames": 1359
+        }
+    },
+    "recommended": true,
+    "recommendedOrder": 100
+}

package/dist/transforms-by-id/rename-command-result-variables/rename-command-result-variables-transform.d.ts

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

package/dist/transforms-by-id/rename-command-result-variables/rename-command-result-variables-transform.js

@@ -0,0 +1,89 @@
+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 BASE_NAME = "commandResult";
+const isCommandResultProperty = (path) => {
+    const memberExpressionPath = path.parentPath;
+    if (!memberExpressionPath.isMemberExpression())
+        return false;
+    const memberExpression = memberExpressionPath.node;
+    if (memberExpression.object !== path.node)
+        return false;
+    if (memberExpression.computed)
+        return false;
+    if (memberExpression.property.type !== "Identifier")
+        return false;
+    return (memberExpression.property.name === "code" ||
+        memberExpression.property.name === "stdout" ||
+        memberExpression.property.name === "stderr");
+};
+const hasCommandResultPattern = (binding) => {
+    let hasCodeProperty = false;
+    let hasOutputProperty = false;
+    for (const referencePath of binding.referencePaths) {
+        if (!referencePath.isIdentifier())
+            continue;
+        if (!isCommandResultProperty(referencePath))
+            continue;
+        const property = referencePath.parentPath.node
+            .property;
+        if (property.type !== "Identifier")
+            continue;
+        if (property.name === "code")
+            hasCodeProperty = true;
+        if (property.name === "stdout" || property.name === "stderr") {
+            hasOutputProperty = true;
+        }
+    }
+    return hasCodeProperty && hasOutputProperty;
+};
+export const renameCommandResultVariablesTransform = {
+    id: "rename-command-result-variables",
+    description: "Renames variables used as command result objects when code/stdout/stderr members are accessed",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const fileInfo of getFilesToProcess(context)) {
+            const renameGroup = new RenameGroup();
+            traverse(fileInfo.ast, {
+                VariableDeclarator(path) {
+                    nodesVisited++;
+                    const id = path.node.id;
+                    if (id.type !== "Identifier")
+                        return;
+                    const currentName = id.name;
+                    if (isStableRenamed(currentName))
+                        return;
+                    if (currentName === BASE_NAME)
+                        return;
+                    const binding = path.scope.getBinding(currentName);
+                    if (!binding)
+                        return;
+                    if (!binding.constant)
+                        return;
+                    if (binding.identifier !== id)
+                        return;
+                    if (binding.referencePaths.length === 0)
+                        return;
+                    if (!hasCommandResultPattern(binding))
+                        return;
+                    renameGroup.add({
+                        scope: binding.scope,
+                        currentName,
+                        baseName: BASE_NAME,
+                    });
+                },
+            });
+            transformationsApplied += renameGroup.apply();
+        }
+        return Promise.resolve({
+            nodesVisited,
+            transformationsApplied,
+        });
+    },
+};

package/dist/transforms-by-id/rename-constructor-variables/get-constructor-base-name-from-expression.d.ts

@@ -0,0 +1,3 @@
+import type { Scope } from "@babel/traverse";
+import type { Expression } from "@babel/types";
+export declare const getConstructorBaseNameFromExpression: (scope: Scope, expression: Expression | null | undefined) => string | undefined;

package/dist/transforms-by-id/rename-constructor-variables/get-constructor-base-name-from-expression.js

@@ -0,0 +1,30 @@
+import * as t from "@babel/types";
+import { isValidBindingIdentifier } from "../../transforms/shared/is-valid-binding-identifier.js";
+import { resolveConstructorNameFromExpression } from "./resolve-constructor-name-from-expression.js";
+import { unwrapTransparentExpression } from "./unwrap-transparent-expression.js";
+const toCamelCaseBaseName = (constructorName) => {
+    const uppercasePrefixMatch = constructorName.match(/^[A-Z]+(?=[A-Z][a-z]|[0-9]|$)/u);
+    if (!uppercasePrefixMatch) {
+        const [firstCharacter = "", ...rest] = constructorName;
+        return `${firstCharacter.toLowerCase()}${rest.join("")}`;
+    }
+    const uppercasePrefix = uppercasePrefixMatch[0];
+    return (uppercasePrefix.toLowerCase() +
+        constructorName.slice(uppercasePrefix.length));
+};
+export const getConstructorBaseNameFromExpression = (scope, expression) => {
+    if (!expression)
+        return undefined;
+    const unwrappedExpression = unwrapTransparentExpression(expression);
+    if (!t.isNewExpression(unwrappedExpression))
+        return undefined;
+    if (!t.isExpression(unwrappedExpression.callee))
+        return undefined;
+    const constructorName = resolveConstructorNameFromExpression(scope, unwrappedExpression.callee);
+    if (!constructorName)
+        return undefined;
+    const baseName = toCamelCaseBaseName(constructorName);
+    if (!isValidBindingIdentifier(baseName))
+        return undefined;
+    return baseName;
+};

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

@@ -0,0 +1,14 @@
+{
+    "notes": "Renames constructor-initialized or constructor-assigned variables by deriving camelCase names from constructor identifiers, member constructors, and local constructor aliases.",
+    "evaluations": {
+        "claude-code-2.1.10:claude-code-2.1.11": {
+            "diffSizePercent": 100.3269456098575,
+            "evaluatedAt": "2026-02-13T08:51:30.726Z",
+            "changedLines": 15609,
+            "durationSeconds": 367.642214666,
+            "stableNames": 1804
+        }
+    },
+    "recommended": true,
+    "recommendedOrder": 201
+}

package/dist/transforms-by-id/rename-constructor-variables/rename-constructor-variables-transform.d.ts

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

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

@@ -0,0 +1,74 @@
+import { createRequire } from "node:module";
+import { isStableRenamed, RenameGroup } from "../../core/stable-naming.js";
+import { getFilesToProcess, } from "../../core/types.js";
+import { getConstructorBaseNameFromExpression } from "./get-constructor-base-name-from-expression.js";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const traverse = require("@babel/traverse").default;
+const queueConstructorRename = (options) => {
+    const { scope, currentName, baseName, group, queuedBindings } = options;
+    if (isStableRenamed(currentName))
+        return;
+    const binding = scope.getBinding(currentName);
+    if (!binding)
+        return;
+    if (queuedBindings.has(binding))
+        return;
+    queuedBindings.add(binding);
+    group.add({
+        scope: binding.scope,
+        currentName,
+        baseName,
+    });
+};
+export const renameConstructorVariablesTransform = {
+    id: "rename-constructor-variables",
+    description: "Renames variables initialized or assigned from constructor calls to constructor-derived names like $dataView and $fooBar",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const fileInfo of getFilesToProcess(context)) {
+            const group = new RenameGroup();
+            const queuedBindings = new Set();
+            traverse(fileInfo.ast, {
+                VariableDeclarator(path) {
+                    nodesVisited++;
+                    const { id } = path.node;
+                    if (id.type !== "Identifier")
+                        return;
+                    const baseName = getConstructorBaseNameFromExpression(path.scope, path.node.init);
+                    if (!baseName)
+                        return;
+                    queueConstructorRename({
+                        scope: path.scope,
+                        currentName: id.name,
+                        baseName,
+                        group,
+                        queuedBindings,
+                    });
+                },
+                AssignmentExpression(path) {
+                    nodesVisited++;
+                    if (path.node.operator !== "=")
+                        return;
+                    if (path.node.left.type !== "Identifier")
+                        return;
+                    const baseName = getConstructorBaseNameFromExpression(path.scope, path.node.right);
+                    if (!baseName)
+                        return;
+                    queueConstructorRename({
+                        scope: path.scope,
+                        currentName: path.node.left.name,
+                        baseName,
+                        group,
+                        queuedBindings,
+                    });
+                },
+            });
+            transformationsApplied += group.apply();
+        }
+        return Promise.resolve({ nodesVisited, transformationsApplied });
+    },
+};

package/dist/transforms-by-id/rename-constructor-variables/resolve-constructor-name-from-expression.d.ts

@@ -0,0 +1,3 @@
+import type { Scope } from "@babel/traverse";
+import type { Expression } from "@babel/types";
+export declare const resolveConstructorNameFromExpression: (scope: Scope, expression: Expression) => string | undefined;

package/dist/transforms-by-id/rename-constructor-variables/resolve-constructor-name-from-expression.js

@@ -0,0 +1,77 @@
+import * as t from "@babel/types";
+import { MAX_ALIAS_RESOLUTION_DEPTH, unwrapTransparentExpression, } from "./unwrap-transparent-expression.js";
+const UPPERCASE_CONSTRUCTOR_PATTERN = /^[A-Z][A-Za-z0-9_$]*$/u;
+const getMemberPropertyName = (memberExpression) => {
+    if (!memberExpression.computed) {
+        if (!t.isIdentifier(memberExpression.property))
+            return undefined;
+        return memberExpression.property.name;
+    }
+    if (t.isStringLiteral(memberExpression.property)) {
+        return memberExpression.property.value;
+    }
+    if (t.isTemplateLiteral(memberExpression.property) &&
+        memberExpression.property.expressions.length === 0 &&
+        memberExpression.property.quasis.length === 1) {
+        return memberExpression.property.quasis[0]?.value.cooked ?? undefined;
+    }
+    return undefined;
+};
+const resolveFromBinding = (binding, visitedBindings, depth) => {
+    if (depth > MAX_ALIAS_RESOLUTION_DEPTH)
+        return undefined;
+    const bindingPath = binding.path;
+    if (bindingPath.isClassDeclaration() || bindingPath.isFunctionDeclaration()) {
+        return binding.identifier.name;
+    }
+    if (!bindingPath.isVariableDeclarator() || !binding.constant) {
+        return undefined;
+    }
+    const { init, id } = bindingPath.node;
+    if (!init)
+        return undefined;
+    const unwrappedInit = unwrapTransparentExpression(init);
+    if (t.isClassExpression(unwrappedInit) ||
+        t.isFunctionExpression(unwrappedInit)) {
+        if (unwrappedInit.id?.name)
+            return unwrappedInit.id.name;
+        return t.isIdentifier(id) ? id.name : undefined;
+    }
+    return resolveFromExpression(bindingPath.scope, unwrappedInit, visitedBindings, depth + 1);
+};
+const resolveFromIdentifier = (scope, identifierName, visitedBindings, depth) => {
+    if (depth > MAX_ALIAS_RESOLUTION_DEPTH)
+        return undefined;
+    const binding = scope.getBinding(identifierName);
+    if (binding) {
+        if (visitedBindings.has(binding))
+            return undefined;
+        visitedBindings.add(binding);
+        const resolvedFromBinding = resolveFromBinding(binding, visitedBindings, depth + 1);
+        if (resolvedFromBinding)
+            return resolvedFromBinding;
+    }
+    return UPPERCASE_CONSTRUCTOR_PATTERN.test(identifierName)
+        ? identifierName
+        : undefined;
+};
+const resolveFromExpression = (scope, expression, visitedBindings, depth) => {
+    if (depth > MAX_ALIAS_RESOLUTION_DEPTH)
+        return undefined;
+    const unwrappedExpression = unwrapTransparentExpression(expression);
+    if (t.isIdentifier(unwrappedExpression)) {
+        return resolveFromIdentifier(scope, unwrappedExpression.name, visitedBindings, depth + 1);
+    }
+    if (t.isMemberExpression(unwrappedExpression) ||
+        t.isOptionalMemberExpression(unwrappedExpression)) {
+        return getMemberPropertyName(unwrappedExpression);
+    }
+    if (t.isClassExpression(unwrappedExpression) ||
+        t.isFunctionExpression(unwrappedExpression)) {
+        return unwrappedExpression.id?.name;
+    }
+    return undefined;
+};
+export const resolveConstructorNameFromExpression = (scope, expression) => {
+    return resolveFromExpression(scope, expression, new Set(), 0);
+};

package/dist/transforms-by-id/rename-constructor-variables/unwrap-transparent-expression.d.ts

@@ -0,0 +1,3 @@
+import type { Expression } from "@babel/types";
+export declare const MAX_ALIAS_RESOLUTION_DEPTH = 8;
+export declare const unwrapTransparentExpression: (expression: Expression) => Expression;

package/dist/transforms-by-id/rename-constructor-variables/unwrap-transparent-expression.js

@@ -0,0 +1,29 @@
+import * as t from "@babel/types";
+export const MAX_ALIAS_RESOLUTION_DEPTH = 8;
+const unwrapSingleTransparentExpression = (expression) => {
+    if (t.isParenthesizedExpression(expression))
+        return expression.expression;
+    if (t.isTSAsExpression(expression))
+        return expression.expression;
+    if (t.isTSSatisfiesExpression(expression))
+        return expression.expression;
+    if (t.isTSTypeAssertion(expression))
+        return expression.expression;
+    if (t.isTSNonNullExpression(expression))
+        return expression.expression;
+    if (t.isTypeCastExpression(expression))
+        return expression.expression;
+    if (t.isSequenceExpression(expression))
+        return expression.expressions.at(-1);
+    return undefined;
+};
+export const unwrapTransparentExpression = (expression) => {
+    let currentExpression = expression;
+    for (let depth = 0; depth < MAX_ALIAS_RESOLUTION_DEPTH; depth += 1) {
+        const nextExpression = unwrapSingleTransparentExpression(currentExpression);
+        if (!nextExpression)
+            return currentExpression;
+        currentExpression = nextExpression;
+    }
+    return currentExpression;
+};

package/dist/transforms-by-id/rename-file-reader-variables/manifest.json

@@ -1,13 +1,14 @@
 {
+    "notes": "Post-pass behavior after rename-constructor-variables: focuses on FileReader event-handler parameter naming for fileReader-like bindings.",
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
             "diffSizePercent": 100,
-            "evaluatedAt": "2026-02-10T06:09:53.201Z",
-            "changedLines": 80,
-            "durationSeconds": 32.424962083,
-            "stableNames": 1359
+            "evaluatedAt": "2026-02-14T07:23:12.948Z",
+            "changedLines": 0,
+            "durationSeconds": 25.987191208,
+            "stableNames": 1357
         }
     },
     "recommended": true,
-    "recommendedOrder": 50
+    "recommendedOrder": 211
 }

package/dist/transforms-by-id/rename-file-reader-variables/rename-file-reader-variables-transform.js

@@ -1,16 +1,51 @@
 import { createRequire } from "node:module";
-import { collectExportedNames } from "../../core/collect-exported-names.js";
+import * as t from "@babel/types";
 import { RenameGroup } from "../../core/stable-naming.js";
 import { getFilesToProcess, } from "../../core/types.js";
-import { isFileReaderConstructor } from "./is-file-reader-constructor.js";
 import { queueFileReaderEventRename } from "./queue-file-reader-event-rename.js";
-import { queueFileReaderRename } from "./queue-file-reader-rename.js";
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 const traverse = require("@babel/traverse").default;
+const FILE_READER_BINDING_PATTERN = /^\$?fileReader(?:Instance)?\d*$/u;
+const isTrackedFileReaderBindingName = (name) => FILE_READER_BINDING_PATTERN.test(name);
+const getMemberPropertyName = (memberExpression) => {
+    if (!memberExpression.computed) {
+        if (!t.isIdentifier(memberExpression.property))
+            return undefined;
+        return memberExpression.property.name;
+    }
+    if (t.isStringLiteral(memberExpression.property)) {
+        return memberExpression.property.value;
+    }
+    if (t.isTemplateLiteral(memberExpression.property) &&
+        memberExpression.property.expressions.length === 0 &&
+        memberExpression.property.quasis.length === 1) {
+        return memberExpression.property.quasis[0]?.value.cooked ?? undefined;
+    }
+    return undefined;
+};
+const isFileReaderConstructorExpression = (expression) => {
+    if (!t.isNewExpression(expression))
+        return false;
+    const callee = expression.callee;
+    if (t.isIdentifier(callee)) {
+        return callee.name === "FileReader";
+    }
+    if (!t.isMemberExpression(callee) && !t.isOptionalMemberExpression(callee)) {
+        return false;
+    }
+    const propertyName = getMemberPropertyName(callee);
+    if (propertyName !== "FileReader")
+        return false;
+    if (!t.isIdentifier(callee.object))
+        return false;
+    return (callee.object.name === "globalThis" ||
+        callee.object.name === "window" ||
+        callee.object.name === "self");
+};
 export const renameFileReaderVariablesTransform = {
     id: "rename-file-reader-variables",
-    description: "Rename variables initialized with new FileReader() to stable fileReader-derived names",
+    description: "Post-pass: renames FileReader event-handler parameters for fileReader-like bindings",
     scope: "file",
     parallelizable: true,
     transform(context) {
@@ -18,33 +53,20 @@ export const renameFileReaderVariablesTransform = {
         let transformationsApplied = 0;
         for (const fileInfo of getFilesToProcess(context)) {
             const renameGroup = new RenameGroup();
-            const exportedNames = collectExportedNames(fileInfo.ast.program);
-            const queuedBindings = new Set();
             const queuedEventBindings = new Set();
             const fileReaderBindings = new Set();
             let directTransformationsApplied = 0;
             traverse(fileInfo.ast, {
                 VariableDeclarator(path) {
                     nodesVisited++;
-                    const { id } = path.node;
-                    if (id.type !== "Identifier") {
+                    if (path.node.id.type !== "Identifier")
                         return;
-                    }
-                    const initPath = path.get("init");
-                    if (Array.isArray(initPath) || !initPath.isNewExpression()) {
+                    if (!isTrackedFileReaderBindingName(path.node.id.name))
                         return;
-                    }
-                    if (!isFileReaderConstructor(initPath)) {
+                    const binding = path.scope.getBinding(path.node.id.name);
+                    if (!binding)
                         return;
-                    }
-                    queueFileReaderRename({
-                        scope: path.scope,
-                        currentName: id.name,
-                        renameGroup,
-                        exportedNames,
-                        queuedBindings,
-                        fileReaderBindings,
-                    });
+                    fileReaderBindings.add(binding);
                 },
                 AssignmentExpression(path) {
                     nodesVisited++;
@@ -54,22 +76,18 @@ export const renameFileReaderVariablesTransform = {
                         if (!binding) {
                             return;
                         }
-                        const rightPath = path.get("right");
-                        if (operator !== "=" ||
-                            Array.isArray(rightPath) ||
-                            !rightPath.isNewExpression() ||
-                            !isFileReaderConstructor(rightPath)) {
+                        if (!isTrackedFileReaderBindingName(binding.identifier.name)) {
+                            return;
+                        }
+                        if (operator !== "=") {
                             fileReaderBindings.delete(binding);
                             return;
                         }
-                        queueFileReaderRename({
-                            scope: path.scope,
-                            currentName: left.name,
-                            renameGroup,
-                            exportedNames,
-                            queuedBindings,
-                            fileReaderBindings,
-                        });
+                        if (isFileReaderConstructorExpression(path.node.right)) {
+                            fileReaderBindings.add(binding);
+                            return;
+                        }
+                        fileReaderBindings.delete(binding);
                         return;
                     }
                     directTransformationsApplied += queueFileReaderEventRename({

package/dist/transforms-by-id/rename-stream-data-chunks/manifest.json

@@ -0,0 +1,14 @@
+{
+    "notes": "Renames stream data callback chunks converted via toString() for stable semantic naming.",
+    "evaluations": {
+        "claude-code-2.1.10:claude-code-2.1.11": {
+            "diffSizePercent": 100,
+            "evaluatedAt": "2026-02-13T08:13:50.155Z",
+            "changedLines": 46,
+            "durationSeconds": 30.382711458000003,
+            "stableNames": 1358
+        }
+    },
+    "recommended": true,
+    "recommendedOrder": 115
+}

package/dist/transforms-by-id/rename-stream-data-chunks/rename-stream-data-chunks-transform.d.ts

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