miniread 1.116.0 → 1.116.2

package/README.md

@@ -102,6 +102,9 @@ Use `miniread` when you need readable JavaScript/TypeScript from minified input
 Development workflow/tooling documentation lives under `development-workflows/`:
 
 - `development-workflows/AGENTS.md` — shared development tooling and workflow helper docs
+- `development-workflows/codex-task-to-worktree.md` — import Codex task patches into local task worktrees
+- `development-workflows/cherry-pick-worktrees-into-main.md` — cherry-pick worktree commits into main, discard conflicts, remove processed worktrees
+- `development-workflows/generalize-overlapping-transforms.md` — pattern for consolidating overlapping transform behavior
 - `development-workflows/new-transform.md` — transform iteration workflow
 - `development-workflows/improve-transform-performance.md` — runtime performance optimization workflow
 - `development-workflows/improve-transform-coverage.md` — coverage improvement workflow

package/dist/transforms/preset-stats.json

@@ -1,6 +1,6 @@
 {
     "recommended": {
-        "diffSizePercent": 25.52727066560835,
-        "notes": "Measured with baseline none: 25.53% of original diff."
+        "diffSizePercent": 26.033752882035,
+        "notes": "Measured with baseline none: 26.03% of original diff."
     }
 }

package/dist/transforms-by-id/rename-platform-win32-flags/add-assignment-win32-rename-candidate.d.ts

@@ -0,0 +1,14 @@
+import type { NodePath, Scope } from "@babel/traverse";
+import type { AssignmentExpression, BinaryExpression } from "@babel/types";
+import { type RenameGroup } from "../../core/stable-naming.js";
+import type { HashRenameEntry } from "./apply-hash-stable-win32-renames.js";
+type AddAssignmentWin32RenameCandidateInput = {
+    getPlatformIdentifierName: (node: BinaryExpression) => string | undefined;
+    getWin32BaseName: (node: BinaryExpression) => "isWindows" | "isNotWindows" | undefined;
+    group: RenameGroup;
+    hashEntries: HashRenameEntry[];
+    path: NodePath<AssignmentExpression>;
+    scope: Scope;
+};
+export declare const addAssignmentWin32RenameCandidate: ({ getPlatformIdentifierName, getWin32BaseName, group, hashEntries, path, scope, }: AddAssignmentWin32RenameCandidateInput) => void;
+export {};

package/dist/transforms-by-id/rename-platform-win32-flags/add-assignment-win32-rename-candidate.js

@@ -0,0 +1,57 @@
+import { isHashBasedStableName, } from "../../core/stable-naming.js";
+import { isSafeProcessBinding } from "./is-safe-process-binding.js";
+const getAssignmentTargetName = (path) => {
+    if (path.node.operator !== "=")
+        return undefined;
+    if (path.node.left.type !== "Identifier")
+        return undefined;
+    return path.node.left.name;
+};
+const getAssignmentBinaryExpression = (path) => {
+    if (path.node.right.type !== "BinaryExpression")
+        return undefined;
+    return path.node.right;
+};
+export const addAssignmentWin32RenameCandidate = ({ getPlatformIdentifierName, getWin32BaseName, group, hashEntries, path, scope, }) => {
+    const assignmentTargetName = getAssignmentTargetName(path);
+    if (!assignmentTargetName)
+        return;
+    const binaryExpression = getAssignmentBinaryExpression(path);
+    if (!binaryExpression)
+        return;
+    const platformIdentifierName = getPlatformIdentifierName(binaryExpression);
+    if (!platformIdentifierName)
+        return;
+    if (!isSafeProcessBinding(path, platformIdentifierName))
+        return;
+    const baseName = getWin32BaseName(binaryExpression);
+    if (!baseName)
+        return;
+    const binding = scope.getBinding(assignmentTargetName);
+    if (!binding)
+        return;
+    if (binding.constant)
+        return;
+    if (binding.constantViolations.length !== 1)
+        return;
+    const firstViolation = binding.constantViolations[0];
+    if (!firstViolation)
+        return;
+    if (firstViolation.node !== path.node)
+        return;
+    const bindingScope = binding.scope;
+    if (isHashBasedStableName(assignmentTargetName)) {
+        hashEntries.push({
+            baseName,
+            binding,
+            currentName: assignmentTargetName,
+            scope: bindingScope,
+        });
+        return;
+    }
+    group.add({
+        scope: bindingScope,
+        currentName: assignmentTargetName,
+        baseName,
+    });
+};

package/dist/transforms-by-id/rename-platform-win32-flags/is-safe-process-binding.d.ts

@@ -1,3 +1,2 @@
 import type { NodePath } from "@babel/traverse";
-import type { VariableDeclarator } from "@babel/types";
-export declare const isSafeProcessBinding: (path: NodePath<VariableDeclarator>, identifierName: string) => boolean;
+export declare const isSafeProcessBinding: (path: NodePath, identifierName: string) => boolean;

package/dist/transforms-by-id/rename-platform-win32-flags/manifest.json

@@ -1,13 +1,13 @@
 {
-    "recommended": true,
-    "recommendedOrder": 50,
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
-            "diffSizePercent": 99.99623032701913,
-            "evaluatedAt": "2026-02-07T21:15:35.720Z",
-            "changedLines": 42,
-            "durationSeconds": 234.291656082,
-            "stableNames": 1358
+            "diffSizePercent": 99.98677098688438,
+            "evaluatedAt": "2026-02-21T16:59:41.380Z",
+            "changedLines": 62,
+            "durationSeconds": 41.748348541,
+            "stableNames": 1359
         }
-    }
+    },
+    "recommended": true,
+    "recommendedOrder": 50
 }

package/dist/transforms-by-id/rename-platform-win32-flags/rename-platform-win32-flags-transform.js

@@ -3,6 +3,7 @@ import { isHashBasedStableName, RenameGroup, } from "../../core/stable-naming.js
 import { getFilesToProcess, } from "../../core/types.js";
 import { applyHashStableWin32Renames, } from "./apply-hash-stable-win32-renames.js";
 import { isSafeProcessBinding } from "./is-safe-process-binding.js";
+import { addAssignmentWin32RenameCandidate } from "./add-assignment-win32-rename-candidate.js";
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 const traverse = require("@babel/traverse").default;
@@ -11,11 +12,16 @@ const ESCAPE_CHARACTER = "\\";
 const isProcessPlatformExpression = (node) => {
     if (node.type !== "MemberExpression")
         return false;
-    if (node.computed)
-        return false;
     if (node.object.type !== "Identifier")
         return false;
     // We intentionally keep this structural and verify process identity separately.
+    if (node.computed) {
+        if (node.property.type !== "StringLiteral")
+            return false;
+        if (node.property.value !== "platform")
+            return false;
+        return true;
+    }
     if (node.property.type !== "Identifier")
         return false;
     if (node.property.name !== "platform")
@@ -28,13 +34,20 @@ const isWin32Literal = (node) => {
     return node.value === WIN32_LITERAL;
 };
 const getWin32BaseName = (node) => {
-    if (node.operator !== "===" && node.operator !== "!==")
+    if (node.operator !== "===" &&
+        node.operator !== "!==" &&
+        node.operator !== "==" &&
+        node.operator !== "!=") {
         return undefined;
+    }
     const matchesLeft = isProcessPlatformExpression(node.left) && isWin32Literal(node.right);
     const matchesRight = isProcessPlatformExpression(node.right) && isWin32Literal(node.left);
     if (!matchesLeft && !matchesRight)
         return undefined;
-    return node.operator === "===" ? "isWindows" : "isNotWindows";
+    if (node.operator === "===" || node.operator === "==") {
+        return "isWindows";
+    }
+    return "isNotWindows";
 };
 const getPlatformIdentifierName = (node) => {
     if (isProcessPlatformExpression(node.left)) {
@@ -99,11 +112,6 @@ export const renamePlatformWin32FlagsTransform = {
                         return;
                     if (!binding.constant)
                         return;
-                    // Intentionally skip single-declaration dead flags to avoid churn;
-                    // unlike generic comparison-flags, this transform targets a narrow,
-                    // semantically named pattern where dead-code renames add little value.
-                    if (binding.referencePaths.length === 0)
-                        return;
                     if (isHashBasedStableName(id.name)) {
                         hashEntries.push({
                             baseName,
@@ -119,6 +127,17 @@ export const renamePlatformWin32FlagsTransform = {
                         baseName,
                     });
                 },
+                AssignmentExpression(path) {
+                    nodesVisited++;
+                    addAssignmentWin32RenameCandidate({
+                        getPlatformIdentifierName,
+                        getWin32BaseName,
+                        group,
+                        hashEntries,
+                        path,
+                        scope: path.scope,
+                    });
+                },
             });
             transformationsApplied += applyHashStableWin32Renames(hashEntries);
             transformationsApplied += group.apply();

package/dist/transforms-by-id/rename-use-reference-sets/get-set-reference-usage.d.ts

@@ -3,6 +3,7 @@ type SetReferenceUsage = {
     isSafe: boolean;
     hasSetMethodCall: boolean;
     hasSizeRead: boolean;
+    hasCurrentRead: boolean;
 };
 export declare const getSetReferenceUsage: (binding: Binding) => SetReferenceUsage;
 export {};

package/dist/transforms-by-id/rename-use-reference-sets/get-set-reference-usage.js

@@ -1,78 +1,163 @@
-const allowedSetMethodCalls = new Set(["add", "has", "delete", "clear"]);
+import { isDisallowedMemberUsageParent } from "./is-disallowed-member-usage-parent.js";
+const allowedSetMethodCalls = new Set([
+    "add",
+    "has",
+    "delete",
+    "clear",
+    "forEach",
+    "entries",
+    "keys",
+    "values",
+]);
+const createResult = (isSafe, usage) => {
+    return {
+        isSafe,
+        hasSetMethodCall: usage.hasSetMethodCall,
+        hasSizeRead: usage.hasSizeRead,
+        hasCurrentRead: usage.hasCurrentRead,
+    };
+};
+const getSafeCurrentRead = (hasSetMethodCall, hasSizeRead, hasCurrentRead, currentMemberPath) => {
+    const usagePath = currentMemberPath.parentPath;
+    if (isDisallowedMemberUsageParent(usagePath, currentMemberPath.node)) {
+        return createResult(false, {
+            hasSetMethodCall,
+            hasSizeRead,
+            hasCurrentRead,
+        });
+    }
+    if (!currentMemberPath.isReferenced()) {
+        return createResult(false, {
+            hasSetMethodCall,
+            hasSizeRead,
+            hasCurrentRead,
+        });
+    }
+    return createResult(true, {
+        hasSetMethodCall,
+        hasSizeRead,
+        hasCurrentRead: true,
+    });
+};
+const getSafeSizeRead = (hasSetMethodCall, hasSizeRead, hasCurrentRead, usagePath) => {
+    const sizeParentPath = usagePath.parentPath;
+    if (isDisallowedMemberUsageParent(sizeParentPath, usagePath.node)) {
+        return createResult(false, {
+            hasSetMethodCall,
+            hasSizeRead,
+            hasCurrentRead,
+        });
+    }
+    if (!usagePath.isReferenced()) {
+        return createResult(false, {
+            hasSetMethodCall,
+            hasSizeRead,
+            hasCurrentRead,
+        });
+    }
+    return createResult(true, {
+        hasSetMethodCall,
+        hasSizeRead: true,
+        hasCurrentRead,
+    });
+};
 export const getSetReferenceUsage = (binding) => {
     let hasSetMethodCall = false;
     let hasSizeRead = false;
+    let hasCurrentRead = false;
     for (const referencePath of binding.referencePaths) {
         if (!referencePath.isIdentifier()) {
-            return { isSafe: false, hasSetMethodCall, hasSizeRead };
+            return createResult(false, {
+                hasSetMethodCall,
+                hasSizeRead,
+                hasCurrentRead,
+            });
         }
         const currentMemberPath = referencePath.parentPath;
         if (!currentMemberPath.isMemberExpression()) {
-            return { isSafe: false, hasSetMethodCall, hasSizeRead };
+            return createResult(false, {
+                hasSetMethodCall,
+                hasSizeRead,
+                hasCurrentRead,
+            });
         }
         if (currentMemberPath.node.computed) {
-            return { isSafe: false, hasSetMethodCall, hasSizeRead };
+            return createResult(false, {
+                hasSetMethodCall,
+                hasSizeRead,
+                hasCurrentRead,
+            });
         }
         const currentProperty = currentMemberPath.get("property");
         if (!currentProperty.isIdentifier({ name: "current" })) {
-            return { isSafe: false, hasSetMethodCall, hasSizeRead };
+            return createResult(false, {
+                hasSetMethodCall,
+                hasSizeRead,
+                hasCurrentRead,
+            });
         }
         const usagePath = currentMemberPath.parentPath;
+        if (usagePath.isOptionalMemberExpression() &&
+            usagePath.node.object === currentMemberPath.node) {
+            return createResult(false, {
+                hasSetMethodCall,
+                hasSizeRead,
+                hasCurrentRead,
+            });
+        }
         if (!usagePath.isMemberExpression()) {
-            return { isSafe: false, hasSetMethodCall, hasSizeRead };
+            const currentRead = getSafeCurrentRead(hasSetMethodCall, hasSizeRead, hasCurrentRead, currentMemberPath);
+            if (!currentRead.isSafe)
+                return currentRead;
+            hasCurrentRead = currentRead.hasCurrentRead;
+            continue;
         }
         if (usagePath.node.computed) {
-            return { isSafe: false, hasSetMethodCall, hasSizeRead };
+            return createResult(false, {
+                hasSetMethodCall,
+                hasSizeRead,
+                hasCurrentRead,
+            });
         }
         const usageProperty = usagePath.get("property");
         if (!usageProperty.isIdentifier()) {
-            return { isSafe: false, hasSetMethodCall, hasSizeRead };
+            return createResult(false, {
+                hasSetMethodCall,
+                hasSizeRead,
+                hasCurrentRead,
+            });
         }
         if (allowedSetMethodCalls.has(usageProperty.node.name)) {
             const callPath = usagePath.parentPath;
             if (!callPath.isCallExpression()) {
-                return { isSafe: false, hasSetMethodCall, hasSizeRead };
+                return createResult(false, {
+                    hasSetMethodCall,
+                    hasSizeRead,
+                    hasCurrentRead,
+                });
             }
             if (callPath.node.callee !== usagePath.node) {
-                return { isSafe: false, hasSetMethodCall, hasSizeRead };
+                return createResult(false, {
+                    hasSetMethodCall,
+                    hasSizeRead,
+                    hasCurrentRead,
+                });
             }
             hasSetMethodCall = true;
             continue;
         }
         if (usageProperty.node.name === "size") {
-            const sizeParentPath = usagePath.parentPath;
-            if (sizeParentPath.isAssignmentExpression() &&
-                sizeParentPath.node.left === usagePath.node) {
-                return { isSafe: false, hasSetMethodCall, hasSizeRead };
-            }
-            if (sizeParentPath.isUpdateExpression() &&
-                sizeParentPath.node.argument === usagePath.node) {
-                return { isSafe: false, hasSetMethodCall, hasSizeRead };
-            }
-            if (sizeParentPath.isUnaryExpression() &&
-                sizeParentPath.node.operator === "delete" &&
-                sizeParentPath.node.argument === usagePath.node) {
-                return { isSafe: false, hasSetMethodCall, hasSizeRead };
-            }
-            if (sizeParentPath.isCallExpression() &&
-                sizeParentPath.node.callee === usagePath.node) {
-                return { isSafe: false, hasSetMethodCall, hasSizeRead };
-            }
-            if (sizeParentPath.isOptionalCallExpression() &&
-                sizeParentPath.node.callee === usagePath.node) {
-                return { isSafe: false, hasSetMethodCall, hasSizeRead };
-            }
-            if (sizeParentPath.isNewExpression() &&
-                sizeParentPath.node.callee === usagePath.node) {
-                return { isSafe: false, hasSetMethodCall, hasSizeRead };
-            }
-            if (!usagePath.isReferenced()) {
-                return { isSafe: false, hasSetMethodCall, hasSizeRead };
-            }
-            hasSizeRead = true;
+            const sizeRead = getSafeSizeRead(hasSetMethodCall, hasSizeRead, hasCurrentRead, usagePath);
+            if (!sizeRead.isSafe)
+                return sizeRead;
+            hasSizeRead = sizeRead.hasSizeRead;
             continue;
         }
-        return { isSafe: false, hasSetMethodCall, hasSizeRead };
+        return createResult(false, {
+            hasSetMethodCall,
+            hasSizeRead,
+            hasCurrentRead,
+        });
     }
-    return { isSafe: true, hasSetMethodCall, hasSizeRead };
+    return createResult(true, { hasSetMethodCall, hasSizeRead, hasCurrentRead });
 };

package/dist/transforms-by-id/rename-use-reference-sets/is-disallowed-member-usage-parent.d.ts

@@ -0,0 +1,3 @@
+import type { NodePath } from "@babel/traverse";
+import type { Node } from "@babel/types";
+export declare const isDisallowedMemberUsageParent: (parentPath: NodePath | null, memberNode: Node) => boolean;

package/dist/transforms-by-id/rename-use-reference-sets/is-disallowed-member-usage-parent.js

@@ -0,0 +1,28 @@
+export const isDisallowedMemberUsageParent = (parentPath, memberNode) => {
+    if (!parentPath)
+        return true;
+    if (parentPath.isAssignmentExpression() &&
+        parentPath.node.left === memberNode) {
+        return true;
+    }
+    if (parentPath.isUpdateExpression() &&
+        parentPath.node.argument === memberNode) {
+        return true;
+    }
+    if (parentPath.isUnaryExpression() &&
+        parentPath.node.operator === "delete" &&
+        parentPath.node.argument === memberNode) {
+        return true;
+    }
+    if (parentPath.isCallExpression() && parentPath.node.callee === memberNode) {
+        return true;
+    }
+    if (parentPath.isOptionalCallExpression() &&
+        parentPath.node.callee === memberNode) {
+        return true;
+    }
+    if (parentPath.isNewExpression() && parentPath.node.callee === memberNode) {
+        return true;
+    }
+    return false;
+};

package/dist/transforms-by-id/rename-use-reference-sets/is-use-reference-set-initializer.js

@@ -1,3 +1,33 @@
+const isUseReferenceCallee = (callee) => {
+    if (!callee)
+        return false;
+    if (callee.type === "V8IntrinsicIdentifier")
+        return false;
+    if (callee.type === "Identifier") {
+        return callee.name === "useRef";
+    }
+    if (callee.type === "MemberExpression") {
+        if (callee.computed)
+            return false;
+        if (callee.property.type !== "Identifier")
+            return false;
+        return callee.property.name === "useRef";
+    }
+    if (callee.type === "SequenceExpression") {
+        const lastExpression = callee.expressions.at(-1);
+        return isUseReferenceCallee(lastExpression);
+    }
+    if (callee.type === "TSAsExpression" || callee.type === "TSTypeAssertion") {
+        return isUseReferenceCallee(callee.expression);
+    }
+    if (callee.type === "TSNonNullExpression") {
+        return isUseReferenceCallee(callee.expression);
+    }
+    if (callee.type === "ParenthesizedExpression") {
+        return isUseReferenceCallee(callee.expression);
+    }
+    return false;
+};
 export const isUseReferenceSetInitializer = (declarator) => {
     const init = declarator.init;
     if (!init)
@@ -30,15 +60,5 @@ export const isUseReferenceSetInitializer = (declarator) => {
         if (setArgument.type === "ArgumentPlaceholder")
             return false;
     }
-    const callee = init.callee;
-    if (callee.type === "Identifier") {
-        return callee.name === "useRef";
-    }
-    if (callee.type !== "MemberExpression")
-        return false;
-    if (callee.computed)
-        return false;
-    if (callee.property.type !== "Identifier")
-        return false;
-    return callee.property.name === "useRef";
+    return isUseReferenceCallee(init.callee);
 };

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

@@ -1,13 +1,13 @@
 {
-    "recommended": true,
-    "recommendedOrder": 100,
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
             "diffSizePercent": 100,
-            "evaluatedAt": "2026-02-08T05:50:45.820Z",
-            "changedLines": 24,
-            "durationSeconds": 28.251205084000002,
+            "evaluatedAt": "2026-02-21T16:46:50.151Z",
+            "changedLines": 38,
+            "durationSeconds": 32.887656167,
             "stableNames": 1358
         }
-    }
+    },
+    "recommended": true,
+    "recommendedOrder": 100
 }

package/dist/transforms-by-id/rename-use-reference-sets/rename-use-reference-sets-transform.js

@@ -9,7 +9,7 @@ const traverse = require("@babel/traverse").default;
 const BASE_NAME = "setRef";
 export const renameUseReferenceSetsTransform = {
     id: "rename-use-reference-sets",
-    description: "Renames useRef(new Set()) variables to $setRef/$setRef2/... or setRef/setRef2/... when usage is limited to safe Set operations on .current.",
+    description: "Renames useRef(new Set()) variables to $setRef/$setRef2/... or setRef/setRef2/... when usage is limited to safe Set operations or read-only .current access.",
     scope: "file",
     parallelizable: true,
     transform(context) {
@@ -37,7 +37,9 @@ export const renameUseReferenceSetsTransform = {
                     const usage = getSetReferenceUsage(binding);
                     if (!usage.isSafe)
                         return;
-                    if (!usage.hasSetMethodCall && !usage.hasSizeRead)
+                    if (!usage.hasSetMethodCall &&
+                        !usage.hasSizeRead &&
+                        !usage.hasCurrentRead)
                         return;
                     group.add({
                         scope: path.scope,

package/dist/transforms-by-id/stabilize-top-level-bindings/collect-first-program-scope-assignments.d.ts

@@ -0,0 +1,9 @@
+import type { Scope } from "@babel/traverse";
+import type { Node } from "@babel/types";
+export declare const collectFirstProgramScopeAssignments: (options: {
+    exportedNames: ReadonlySet<string>;
+    programScope: Scope;
+}) => Map<string, {
+    rhs: Node;
+    statementIndex: number;
+}>;

package/dist/transforms-by-id/stabilize-top-level-bindings/collect-first-program-scope-assignments.js

@@ -0,0 +1,107 @@
+import * as t from "@babel/types";
+import { isStableRenamed } from "../../core/stable-naming.js";
+import { hasDisallowedFunctionClassAssignmentReference } from "./has-disallowed-function-class-assignment-reference.js";
+const ALWAYS_STABLE_REFERENCE_IDENTIFIER_NAMES = [
+    "__dirname",
+    "__filename",
+    "arguments",
+    "Buffer",
+    "Promise",
+    "clearInterval",
+    "clearTimeout",
+    "console",
+    "document",
+    "eval",
+    "exports",
+    "global",
+    "globalThis",
+    "module",
+    "process",
+    "queueMicrotask",
+    "require",
+    "self",
+    "setInterval",
+    "setTimeout",
+    "window",
+];
+const getTopLevelAssignmentPosition = (path) => {
+    let current = path;
+    let fromFunctionOrClass = false;
+    while (current.parentPath) {
+        if (current.isFunction())
+            fromFunctionOrClass = true;
+        if (current.isClass())
+            fromFunctionOrClass = true;
+        if (current.parentPath.isProgram()) {
+            return typeof current.key === "number"
+                ? { statementIndex: current.key, fromFunctionOrClass }
+                : undefined;
+        }
+        current = current.parentPath;
+    }
+    return undefined;
+};
+export const collectFirstProgramScopeAssignments = (options) => {
+    const { exportedNames, programScope } = options;
+    const allowedReferenceIdentifierNames = new Set([
+        ...Object.keys(programScope.globals),
+        ...exportedNames,
+        ...ALWAYS_STABLE_REFERENCE_IDENTIFIER_NAMES,
+        "Infinity",
+        "NaN",
+        "undefined",
+    ]);
+    const firstAssignmentByName = new Map();
+    for (const [name, binding] of Object.entries(programScope.bindings)) {
+        if (isStableRenamed(name))
+            continue;
+        if (exportedNames.has(name))
+            continue;
+        let firstAssignment;
+        for (const violation of binding.constantViolations) {
+            const assignmentPath = violation.isAssignmentExpression()
+                ? violation
+                : violation.parentPath?.isAssignmentExpression()
+                    ? violation.parentPath
+                    : undefined;
+            if (!assignmentPath)
+                continue;
+            const assignmentExpression = assignmentPath.node;
+            if (assignmentExpression.operator !== "=")
+                continue;
+            if (!t.isIdentifier(assignmentExpression.left, { name }))
+                continue;
+            const assignmentPosition = getTopLevelAssignmentPosition(assignmentPath);
+            if (!assignmentPosition)
+                continue;
+            if (assignmentPosition.fromFunctionOrClass &&
+                hasDisallowedFunctionClassAssignmentReference({
+                    rhs: assignmentExpression.right,
+                    currentName: name,
+                    programScope,
+                    allowedReferenceIdentifierNames,
+                })) {
+                continue;
+            }
+            const statementIndex = assignmentPosition.statementIndex;
+            const nodeStart = assignmentExpression.start ?? Number.MAX_SAFE_INTEGER;
+            if (!firstAssignment ||
+                statementIndex < firstAssignment.statementIndex ||
+                (statementIndex === firstAssignment.statementIndex &&
+                    nodeStart < firstAssignment.nodeStart)) {
+                firstAssignment = {
+                    rhs: assignmentExpression.right,
+                    statementIndex,
+                    nodeStart,
+                };
+            }
+        }
+        if (!firstAssignment)
+            continue;
+        firstAssignmentByName.set(name, {
+            rhs: firstAssignment.rhs,
+            statementIndex: firstAssignment.statementIndex,
+        });
+    }
+    return firstAssignmentByName;
+};

package/dist/transforms-by-id/stabilize-top-level-bindings/collect-nested-program-scope-variable-initializers.js

@@ -4,29 +4,29 @@ export const collectNestedProgramScopeVariableInitializers = (options) => {
     const { node, statementIndex, exportedNames, programScope, firstAssignmentByName, } = options;
     const results = [];
     const tryAddFromVariableDeclarator = (variableDeclarator) => {
-        if (!t.isIdentifier(variableDeclarator.id))
-            return;
-        const name = variableDeclarator.id.name;
-        if (isStableRenamed(name))
-            return;
-        if (exportedNames.has(name))
-            return;
         if (!variableDeclarator.init)
             return;
-        // `var` declarations inside top-level blocks (e.g. `if (...) { var x = ... }`) are
-        // still program-scope bindings. Only include them if the binding actually belongs
-        // to the program scope (not a nested function scope).
-        const binding = programScope.getBinding(name);
-        if (binding?.scope !== programScope)
-            return;
-        const assignmentInfo = firstAssignmentByName.get(name);
-        if (assignmentInfo && assignmentInfo.statementIndex < statementIndex) {
-            // Precedence rule: if a binding is written via a direct Program-body assignment
-            // before a later initializer (including nested `var` redeclarations), prefer the
-            // first write for stable naming.
-            return;
+        const names = Object.keys(t.getBindingIdentifiers(variableDeclarator.id));
+        for (const name of names) {
+            if (isStableRenamed(name))
+                continue;
+            if (exportedNames.has(name))
+                continue;
+            // `var` declarations inside top-level blocks (e.g. `if (...) { var x = ... }`) are
+            // still program-scope bindings. Only include them if the binding actually belongs
+            // to the program scope (not a nested function scope).
+            const binding = programScope.getBinding(name);
+            if (binding?.scope !== programScope)
+                continue;
+            const assignmentInfo = firstAssignmentByName.get(name);
+            if (assignmentInfo && assignmentInfo.statementIndex < statementIndex) {
+                // Precedence rule: if a binding is written via an earlier top-level assignment
+                // before a later initializer (including nested `var` redeclarations), prefer the
+                // first write for stable naming.
+                continue;
+            }
+            results.push({ name, init: variableDeclarator.init });
         }
-        results.push({ name, init: variableDeclarator.init });
     };
     const visit = (nodeToVisit) => {
         if (t.isFunction(nodeToVisit))

package/dist/transforms-by-id/stabilize-top-level-bindings/collect-rename-candidates.js

@@ -1,7 +1,7 @@
 import * as t from "@babel/types";
 import { isStableRenamed } from "../../core/stable-naming.js";
 import { hashFingerprintNode } from "../../core/fingerprint/hash-fingerprint-node.js";
-import { collectFirstProgramBodyAssignments } from "./collect-first-program-body-assignments.js";
+import { collectFirstProgramScopeAssignments } from "./collect-first-program-scope-assignments.js";
 import { collectNestedProgramScopeVariableInitializers } from "./collect-nested-program-scope-variable-initializers.js";
 import { addRenameCandidate } from "./rename-candidate.js";
 export const collectRenameCandidates = (options) => {
@@ -14,8 +14,7 @@ export const collectRenameCandidates = (options) => {
     // / assignment we encounter for that binding.
     const seenCandidateNames = new Set();
     let nodesVisited = 0;
-    const firstAssignmentByName = collectFirstProgramBodyAssignments({
-        program,
+    const firstAssignmentByName = collectFirstProgramScopeAssignments({
         exportedNames,
         programScope,
     });
@@ -36,35 +35,40 @@ export const collectRenameCandidates = (options) => {
         if (t.isVariableDeclaration(effectiveStmt)) {
             const variableDeclaration = effectiveStmt;
             for (const decl of variableDeclaration.declarations) {
-                if (!t.isIdentifier(decl.id))
-                    continue;
-                const name = decl.id.name;
-                if (isStableRenamed(name))
-                    continue;
-                if (exportedNames.has(name))
+                const names = Object.keys(t.getBindingIdentifiers(decl.id));
+                if (names.length === 0)
                     continue;
                 if (!decl.init) {
                     // No initializer: if there's a later top-level `name = ...`, we'll pick it up
                     // from `firstAssignmentByName` below.
                     continue;
                 }
-                const assignmentInfo = firstAssignmentByName.get(name);
-                if (assignmentInfo && assignmentInfo.statementIndex < statementIndex) {
-                    // Precedence rule: if a binding is written via a direct Program-body assignment
-                    // before a later redeclaration initializer, prefer the first write for stable
-                    // naming. Example: `var a; a = 1; var a = 2;` hashes based on `1`, not `2`.
-                    continue;
-                }
                 const hash = hashFingerprintNode(decl.init);
-                addRenameCandidate({
-                    candidates,
-                    hashToNames,
-                    seenCandidateNames,
-                    name,
-                    hash,
-                    kind: variableDeclaration.kind,
-                    scope: programScope,
-                });
+                for (const name of names) {
+                    if (isStableRenamed(name))
+                        continue;
+                    if (exportedNames.has(name))
+                        continue;
+                    const assignmentInfo = firstAssignmentByName.get(name);
+                    if (variableDeclaration.kind !== "const" &&
+                        assignmentInfo &&
+                        assignmentInfo.statementIndex < statementIndex) {
+                        // Precedence rule: if a mutable binding is written via an earlier top-level
+                        // assignment before a later redeclaration initializer, prefer the first write
+                        // for stable naming. Example: `var a; a = 1; var a = 2;` hashes based on `1`,
+                        // not `2`.
+                        continue;
+                    }
+                    addRenameCandidate({
+                        candidates,
+                        hashToNames,
+                        seenCandidateNames,
+                        name,
+                        hash,
+                        kind: variableDeclaration.kind,
+                        scope: programScope,
+                    });
+                }
             }
         }
         else if (t.isFunctionDeclaration(effectiveStmt)) {
@@ -156,7 +160,8 @@ export const collectRenameCandidates = (options) => {
             }
         }
     }
-    // Pass 2: Add the first write for any binding that hasn't already been fingerprinted.
+    // Pass 2: Add the first top-level write for any binding that hasn't already
+    // been fingerprinted.
     for (const [name, { rhs }] of firstAssignmentByName) {
         if (seenCandidateNames.has(name))
             continue;

package/dist/transforms-by-id/stabilize-top-level-bindings/has-disallowed-function-class-assignment-reference.d.ts

@@ -0,0 +1,8 @@
+import type { Scope } from "@babel/traverse";
+import type { Node } from "@babel/types";
+export declare const hasDisallowedFunctionClassAssignmentReference: (options: {
+    rhs: Node;
+    currentName: string;
+    programScope: Scope;
+    allowedReferenceIdentifierNames: ReadonlySet<string>;
+}) => boolean;

package/dist/transforms-by-id/stabilize-top-level-bindings/has-disallowed-function-class-assignment-reference.js

@@ -0,0 +1,74 @@
+import * as t from "@babel/types";
+import { isStableRenamed } from "../../core/stable-naming.js";
+const isNonReferenceIdentifier = (parent, parentKey) => {
+    if (!parent || !parentKey)
+        return false;
+    if (t.isMemberExpression(parent) || t.isOptionalMemberExpression(parent)) {
+        return parentKey === "property" && !parent.computed;
+    }
+    if (t.isObjectProperty(parent) ||
+        t.isObjectMethod(parent) ||
+        t.isClassMethod(parent) ||
+        t.isClassProperty(parent)) {
+        return parentKey === "key" && !parent.computed;
+    }
+    return false;
+};
+const collectReferencedIdentifierNames = (node, identifiers, parent, parentKey) => {
+    if (t.isIdentifier(node)) {
+        if (!isNonReferenceIdentifier(parent, parentKey)) {
+            identifiers.add(node.name);
+        }
+        return;
+    }
+    const keys = t.VISITOR_KEYS[node.type];
+    if (!keys)
+        return;
+    const nodeRecord = node;
+    for (const key of keys) {
+        const value = nodeRecord[key];
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                if (item && typeof item === "object" && "type" in item) {
+                    collectReferencedIdentifierNames(item, identifiers, node, key);
+                }
+            }
+            continue;
+        }
+        if (value && typeof value === "object" && "type" in value) {
+            collectReferencedIdentifierNames(value, identifiers, node, key);
+        }
+    }
+};
+const isProgramScopeConstBinding = (options) => {
+    const { programScope, identifierName } = options;
+    const referencedBinding = programScope.getBinding(identifierName);
+    return (referencedBinding?.scope === programScope &&
+        referencedBinding.kind === "const");
+};
+const isAllowedReferenceIdentifierName = (options) => {
+    const { currentName, identifierName, programScope, allowedReferenceIdentifierNames, } = options;
+    if (identifierName === currentName)
+        return true;
+    if (isStableRenamed(identifierName))
+        return true;
+    if (allowedReferenceIdentifierNames.has(identifierName))
+        return true;
+    return isProgramScopeConstBinding({ programScope, identifierName });
+};
+export const hasDisallowedFunctionClassAssignmentReference = (options) => {
+    const { rhs, currentName, programScope, allowedReferenceIdentifierNames } = options;
+    const referencedIdentifierNames = new Set();
+    collectReferencedIdentifierNames(rhs, referencedIdentifierNames);
+    for (const identifierName of referencedIdentifierNames) {
+        if (!isAllowedReferenceIdentifierName({
+            currentName,
+            identifierName,
+            programScope,
+            allowedReferenceIdentifierNames,
+        })) {
+            return true;
+        }
+    }
+    return false;
+};

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

@@ -1,14 +1,14 @@
 {
-    "recommended": true,
-    "recommendedOrder": 1,
-    "notes": "Renames program-scope bindings to stable `$h_<hash>` names (simple identifiers only; destructuring patterns are skipped; uninitialized var/let bindings are stabilized only via direct top-level `x = ...` assignment statements; collisions are disambiguated with an encounter-order suffix). For classic scripts/UMD bundles, renaming globals can still be risky; see transform description and safety gates. Note: in scripts, sloppy-mode `this.foo` is treated conservatively as a possible global-object property lookup, and dynamic computed global-object lookups (including `this[expr]`) cause `var`/`function` renames to be skipped for the file. Default behavior is now unsafe with respect to dynamic-name hazards (e.g. direct eval): it will still run, which improves diff stability but may produce non-runnable output.",
+    "notes": "Renames program-scope bindings to stable `$h_<hash>` names (including destructuring-bound identifiers; uninitialized var/let bindings are stabilized via their first program-scope `x = ...` assignment. Assignments discovered inside function/class bodies are considered only when RHS identifier references stay in a stable allowlist: globals/known runtime names, already-stabilized names, self-reference, or program-scope const bindings; collisions are disambiguated with an encounter-order suffix). For classic scripts/UMD bundles, renaming globals can still be risky; see transform description and safety gates. Note: in scripts, sloppy-mode `this.foo` is treated conservatively as a possible global-object property lookup, and dynamic computed global-object lookups (including `this[expr]`) cause `var`/`function` renames to be skipped for the file. Default behavior is now unsafe with respect to dynamic-name hazards (e.g. direct eval): it will still run, which improves diff stability but may produce non-runnable output.",
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
-            "diffSizePercent": 79.11224201300537,
-            "evaluatedAt": "2026-02-07T21:20:02.357Z",
-            "changedLines": 108399,
-            "durationSeconds": 240.84553921,
-            "stableNames": 14374
+            "diffSizePercent": 77.95101485429187,
+            "evaluatedAt": "2026-02-21T15:43:38.877Z",
+            "changedLines": 114776,
+            "durationSeconds": 43.780172209,
+            "stableNames": 15218
         }
-    }
+    },
+    "recommended": true,
+    "recommendedOrder": 1
 }

package/package.json

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

package/dist/transforms-by-id/stabilize-top-level-bindings/collect-first-program-body-assignments.d.ts

@@ -1,12 +0,0 @@
-import type { Scope } from "@babel/traverse";
-import type { Node, Program } from "@babel/types";
-type FirstProgramBodyAssignment = {
-    rhs: Node;
-    statementIndex: number;
-};
-export declare const collectFirstProgramBodyAssignments: (options: {
-    program: Program;
-    exportedNames: ReadonlySet<string>;
-    programScope: Scope;
-}) => Map<string, FirstProgramBodyAssignment>;
-export {};

package/dist/transforms-by-id/stabilize-top-level-bindings/collect-first-program-body-assignments.js

@@ -1,29 +0,0 @@
-import * as t from "@babel/types";
-import { isStableRenamed } from "../../core/stable-naming.js";
-export const collectFirstProgramBodyAssignments = (options) => {
-    const { program, exportedNames, programScope } = options;
-    const firstAssignmentByName = new Map();
-    for (const [statementIndex, stmt] of program.body.entries()) {
-        if (!t.isExpressionStatement(stmt))
-            continue;
-        const expression = stmt.expression;
-        if (!t.isAssignmentExpression(expression))
-            continue;
-        if (expression.operator !== "=")
-            continue;
-        const left = expression.left;
-        if (!t.isIdentifier(left))
-            continue;
-        const name = left.name;
-        if (firstAssignmentByName.has(name))
-            continue;
-        if (isStableRenamed(name))
-            continue;
-        if (exportedNames.has(name))
-            continue;
-        if (!programScope.getBinding(name))
-            continue;
-        firstAssignmentByName.set(name, { rhs: expression.right, statementIndex });
-    }
-    return firstAssignmentByName;
-};