miniread 1.67.0 → 1.69.0

package/dist/{transforms/stabilize-top-level-bindings → core/fingerprint}/fingerprint-scalar-fields.js

@@ -1,5 +1,16 @@
 import * as t from "@babel/types";
 const encodeScalar = (value) => value === undefined ? "undefined" : JSON.stringify(value);
+const extractKeyName = (key) => {
+    if (t.isIdentifier(key))
+        return key.name;
+    if (t.isStringLiteral(key))
+        return key.value;
+    if (t.isNumericLiteral(key))
+        return String(key.value);
+    if (t.isPrivateName(key))
+        return `#${key.id.name}`;
+    return undefined;
+};
 export const fingerprintScalarFields = (node) => {
     if (node.type === "AssignmentExpression" ||
         node.type === "BinaryExpression" ||
@@ -59,42 +70,13 @@ export const fingerprintScalarFields = (node) => {
             `static=${encodeScalar(node.static)}`,
             `computed=${encodeScalar(node.computed)}`,
         ];
-        if (node.type === "ObjectMethod") {
-            const computed = node.computed;
-            const key = node.key;
-            if (computed === true) {
-                // For computed keys, the fingerprint comes from the key expression itself.
-            }
-            else {
-                const keyName = t.isIdentifier(key)
-                    ? key.name
-                    : t.isStringLiteral(key)
-                        ? key.value
-                        : t.isNumericLiteral(key)
-                            ? String(key.value)
-                            : t.isPrivateName(key)
-                                ? `#${key.id.name}`
-                                : undefined;
-                fields.push(`keyName=${encodeScalar(keyName)}`);
-            }
-        }
-        if (node.type === "ClassMethod" || node.type === "ClassPrivateMethod") {
+        if (node.type === "ObjectMethod" ||
+            node.type === "ClassMethod" ||
+            node.type === "ClassPrivateMethod") {
             const computed = node.computed;
             const key = node.key;
-            if (computed === true) {
-                // For computed keys, the fingerprint comes from the key expression itself.
-            }
-            else {
-                const keyName = t.isIdentifier(key)
-                    ? key.name
-                    : t.isStringLiteral(key)
-                        ? key.value
-                        : t.isNumericLiteral(key)
-                            ? String(key.value)
-                            : t.isPrivateName(key)
-                                ? `#${key.id.name}`
-                                : undefined;
-                fields.push(`keyName=${encodeScalar(keyName)}`);
+            if (computed !== true) {
+                fields.push(`keyName=${encodeScalar(extractKeyName(key))}`);
             }
         }
         return fields;
@@ -103,36 +85,15 @@ export const fingerprintScalarFields = (node) => {
         const computed = node.computed;
         const key = node.key;
         const fields = [`computed=${encodeScalar(computed)}`];
-        if (computed === true) {
-            // For computed keys, the fingerprint comes from the key expression itself.
-            return fields;
+        if (computed !== true) {
+            fields.push(`keyName=${encodeScalar(extractKeyName(key))}`);
         }
-        const keyName = t.isIdentifier(key)
-            ? key.name
-            : t.isStringLiteral(key)
-                ? key.value
-                : t.isNumericLiteral(key)
-                    ? String(key.value)
-                    : t.isPrivateName(key)
-                        ? `#${key.id.name}`
-                        : undefined;
-        fields.push(`keyName=${encodeScalar(keyName)}`);
         return fields;
     }
     if (node.type === "ClassProperty" || node.type === "ClassPrivateProperty") {
         const computed = node.computed;
         const key = node.key;
-        const keyName = computed === true
-            ? undefined
-            : t.isIdentifier(key)
-                ? key.name
-                : t.isStringLiteral(key)
-                    ? key.value
-                    : t.isNumericLiteral(key)
-                        ? String(key.value)
-                        : t.isPrivateName(key)
-                            ? `#${key.id.name}`
-                            : undefined;
+        const keyName = computed === true ? undefined : extractKeyName(key);
         return [
             `static=${encodeScalar(node.static)}`,
             `computed=${encodeScalar(computed)}`,
@@ -142,12 +103,7 @@ export const fingerprintScalarFields = (node) => {
     if (node.type === "ImportSpecifier") {
         const imported = node
             .imported;
-        const importedName = t.isIdentifier(imported)
-            ? imported.name
-            : t.isStringLiteral(imported)
-                ? imported.value
-                : undefined;
-        return [`importedName=${encodeScalar(importedName)}`];
+        return [`importedName=${encodeScalar(extractKeyName(imported))}`];
     }
     return [];
 };

package/dist/{transforms/stabilize-top-level-bindings → core/fingerprint}/serialize-fingerprint-node.js

@@ -26,17 +26,15 @@ const pushNodeTasks = (stack, node) => {
     let visitorKeys = keys;
     // For non-computed member keys, we already serialize `keyName` via scalar fields.
     // Skipping the `key` child keeps fingerprints stable across equivalent key syntax
-    // like `{ foo: 1 }` vs `{ \"foo\": 1 }`.
+    // like `{ foo: 1 }` vs `{ "foo": 1 }`.
     const computed = node.computed;
-    if (computed === true) {
-        // Keep the key expression for computed properties.
-    }
-    else if (node.type === "ObjectProperty" ||
-        node.type === "ObjectMethod" ||
-        node.type === "ClassMethod" ||
-        node.type === "ClassPrivateMethod" ||
-        node.type === "ClassProperty" ||
-        node.type === "ClassPrivateProperty") {
+    if (computed !== true &&
+        (node.type === "ObjectProperty" ||
+            node.type === "ObjectMethod" ||
+            node.type === "ClassMethod" ||
+            node.type === "ClassPrivateMethod" ||
+            node.type === "ClassProperty" ||
+            node.type === "ClassPrivateProperty")) {
         visitorKeys = keys.filter((key) => key !== "key");
     }
     const nodeTasks = [{ kind: "text", text: node.type }];

package/dist/core/stable-naming.d.ts

@@ -6,6 +6,9 @@
  *
  * Reserved prefixes:
  * - `$h_`: used by `stabilize-top-level-bindings` for content-hash-based names.
+ * - `$f_`: used by `stabilize-nested-bindings` for factory-local content-hash-based names.
+ * - `$v_`: used by `stabilize-deferred-top-level-bindings` and `stabilize-deferred-stable-rhs`
+ *          for deferred variable names derived from enclosing function or RHS hashes.
  *
  * - Stable names (`$timeoutId`): Readable AND deterministic across versions
  * - Readable names (`timeoutId`): Semantic but order-dependent
@@ -16,6 +19,12 @@ import type { Scope } from "@babel/traverse";
  * Transforms should skip variables with this prefix.
  */
 export declare const isStableRenamed: (name: string) => boolean;
+/**
+ * Returns true if the name uses a content-hash-based stable prefix
+ * (`$h_`, `$f_`, or `$v_`). Use this to check whether a binding was
+ * stabilized by one of the hash-based stabilization transforms.
+ */
+export declare const isHashBasedStableName: (name: string) => boolean;
 /**
  * Entry for a planned rename operation.
  */

package/dist/core/stable-naming.js

@@ -6,6 +6,9 @@
  *
  * Reserved prefixes:
  * - `$h_`: used by `stabilize-top-level-bindings` for content-hash-based names.
+ * - `$f_`: used by `stabilize-nested-bindings` for factory-local content-hash-based names.
+ * - `$v_`: used by `stabilize-deferred-top-level-bindings` and `stabilize-deferred-stable-rhs`
+ *          for deferred variable names derived from enclosing function or RHS hashes.
  *
  * - Stable names (`$timeoutId`): Readable AND deterministic across versions
  * - Readable names (`timeoutId`): Semantic but order-dependent
@@ -20,6 +23,12 @@ const STABLE_PREFIX = "$";
 export const isStableRenamed = (name) => {
     return name.startsWith(STABLE_PREFIX);
 };
+/**
+ * Returns true if the name uses a content-hash-based stable prefix
+ * (`$h_`, `$f_`, or `$v_`). Use this to check whether a binding was
+ * stabilized by one of the hash-based stabilization transforms.
+ */
+export const isHashBasedStableName = (name) => name.startsWith("$h_") || name.startsWith("$f_") || name.startsWith("$v_");
 /**
  * Creates a stable name by adding the $ prefix.
  * Internal helper - prefer using RenameGroup which handles stability logic automatically.

package/dist/transforms/_generated/manifest.js

@@ -334,6 +334,21 @@ const manifestData = {
         notes: "Auto-added by evaluation script. Measured with baseline none: -0.28%. Enabled in the recommended preset for readability and to normalize variable declarations even when line diffs increase.",
         evaluations: { "legacy:evaluation": { "evaluatedAt": "2026-01-25T20:21:14.926Z", "changedLines": 208592, "durationSeconds": 0, "stableNames": 0, "diffSizePercent": 100.27969913444457 }, "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 100.27969913444457, "evaluatedAt": "2026-01-25T23:41:19.807Z", "changedLines": 208592, "durationSeconds": 65.61050708399999, "stableNames": 1357 } },
     },
+    "stabilize-deferred-stable-rhs": {
+        recommended: true,
+        notes: "Stabilizes deferred top-level vars whose RHS contains only stable identifiers (globals or $h_/$f_/$v_ prefixed names). Derives names by hashing the RHS code. Complements stabilize-deferred-top-level-bindings by handling multi-var functions.",
+        evaluations: { "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 95.54, "evaluatedAt": "2026-02-05T18:30:00.000Z", "changedLines": 3730, "durationSeconds": 30, "stableNames": 1741 } },
+    },
+    "stabilize-deferred-top-level-bindings": {
+        recommended: true,
+        notes: "Stabilizes top-level var declarations that are initialized inside stable-named functions (lazy init pattern). Only applies when the enclosing function has exactly one such deferred var to avoid order-dependent naming. Renames ~750 vars but diff reduction is minimal (0.03%) because most vars already have consistent minified names between versions. The stabilization helps when minifiers do vary names.",
+        evaluations: { "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 99.97, "evaluatedAt": "2026-02-05T17:32:00.000Z", "changedLines": 753, "durationSeconds": 26, "stableNames": 2110 } },
+    },
+    "stabilize-nested-bindings": {
+        recommended: true,
+        notes: "Stabilizes local bindings inside CommonJS factory callbacks using content-hash naming ($f_<hash>). Must run AFTER stabilize-top-level-bindings. Combined with top-level stabilization, achieves 33.49% diff size (67% reduction from baseline).",
+        evaluations: { "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 43.68, "evaluatedAt": "2026-02-05T13:38:00.000Z", "changedLines": 47159, "durationSeconds": 60, "stableNames": 14374 } },
+    },
     "stabilize-top-level-bindings": {
         recommended: true,
         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.",
@@ -371,6 +386,9 @@ export const manifestEntries = Object.entries(transformRegistry)
     .toSorted((a, b) => a.id.localeCompare(b.id));
 export const recommendedTransformIds = [
     "stabilize-top-level-bindings",
+    "stabilize-nested-bindings",
+    "stabilize-deferred-top-level-bindings",
+    "stabilize-deferred-stable-rhs",
     "expand-boolean-literals",
     "expand-sequence-expressions-v5",
     "expand-special-number-literals",

package/dist/transforms/_generated/registry.js

@@ -68,6 +68,9 @@ import { replaceDynamicRequireEvalTransform } from "../replace-dynamic-require-e
 import { simplifyBooleanNegationsTransform } from "../simplify-boolean-negations/simplify-boolean-negations-transform.js";
 import { simplifyStringTrimTransform } from "../simplify-string-trim/simplify-string-trim-transform.js";
 import { splitVariableDeclarationsTransform } from "../split-variable-declarations/split-variable-declarations-transform.js";
+import { stabilizeDeferredStableRhsTransform } from "../stabilize-deferred-stable-rhs/stabilize-deferred-stable-rhs-transform.js";
+import { stabilizeDeferredTopLevelBindingsTransform } from "../stabilize-deferred-top-level-bindings/stabilize-deferred-top-level-bindings-transform.js";
+import { stabilizeNestedBindingsTransform } from "../stabilize-nested-bindings/stabilize-nested-bindings-transform.js";
 import { stabilizeTopLevelBindingsTransform } from "../stabilize-top-level-bindings/stabilize-top-level-bindings-transform.js";
 import { useObjectPropertyShorthandTransform } from "../use-object-property-shorthand/use-object-property-shorthand-transform.js";
 import { useObjectShorthandTransform } from "../use-object-shorthand/use-object-shorthand-transform.js";
@@ -141,6 +144,9 @@ export const transformRegistry = {
     [simplifyBooleanNegationsTransform.id]: simplifyBooleanNegationsTransform,
     [simplifyStringTrimTransform.id]: simplifyStringTrimTransform,
     [splitVariableDeclarationsTransform.id]: splitVariableDeclarationsTransform,
+    [stabilizeDeferredStableRhsTransform.id]: stabilizeDeferredStableRhsTransform,
+    [stabilizeDeferredTopLevelBindingsTransform.id]: stabilizeDeferredTopLevelBindingsTransform,
+    [stabilizeNestedBindingsTransform.id]: stabilizeNestedBindingsTransform,
     [stabilizeTopLevelBindingsTransform.id]: stabilizeTopLevelBindingsTransform,
     [useObjectPropertyShorthandTransform.id]: useObjectPropertyShorthandTransform,
     [useObjectShorthandTransform.id]: useObjectShorthandTransform,

package/dist/transforms/preset-stats.json

@@ -1,6 +1,6 @@
 {
     "recommended": {
-        "diffSizePercent": 78.49967015361418,
-        "notes": "Measured with baseline none: 78.50% of original diff. Stats re-evaluated against updated sources (Feb 2026)."
+        "diffSizePercent": 33.47412783006388,
+        "notes": "Measured with baseline none: 33.47% of original diff."
     }
 }

package/dist/transforms/recommended-transform-order.d.ts

@@ -4,4 +4,4 @@
  * This lets us tune transform interactions intentionally instead of relying on
  * alphabetical ID sorting.
  */
-export declare const recommendedTransformOrder: readonly ["stabilize-top-level-bindings", "expand-boolean-literals", "expand-sequence-expressions-v5", "expand-special-number-literals", "expand-typeof-undefined-comparisons", "expand-undefined-literals", "remove-redundant-else", "rename-arguments-length-flags", "rename-asap-wrappers", "rename-awaiter-parameters", "rename-awaiter-helper-functions", "rename-buffer-variables", "rename-to-buffer-results", "rename-catch-parameters", "rename-promise-catch-parameters", "rename-char-code-at", "rename-charcode-variables-v2", "rename-client-aliases", "rename-comparison-flags", "rename-date-now-start-times", "rename-default-options-parameters", "rename-deferred-resolve-parameters", "rename-destructured-aliases", "rename-rest-parameters", "rename-execfile-arguments", "rename-error-first-callback-parameters", "rename-error-variables", "rename-event-parameters", "rename-http-server-parameters", "rename-fs-sync-variables", "rename-http-method-parameters", "rename-interval-ids", "rename-loop-index-variables-v3", "rename-loop-length-variables", "rename-document-fragment-variables", "rename-object-keys-variables", "rename-object-keys-iterator-variables", "rename-parameters-to-match-properties-v2", "rename-promise-executor-parameters-v2", "rename-range-parameters", "rename-read-file-lines", "rename-regex-builders", "rename-search-parameters-variables", "rename-string-split-variables", "rename-this-aliases", "rename-timeout-ids", "rename-typeof-variables", "rename-typescript-helper-aliases", "rename-uint8array-concat-variables", "rename-url-parameters", "rename-url-variables", "rename-use-reference-guards-v2", "rename-use-reference-sets", "rename-worker-handles", "simplify-boolean-negations", "simplify-string-trim", "split-variable-declarations", "use-optional-chaining", "use-object-property-shorthand", "use-object-shorthand", "replace-dynamic-require-eval"];
+export declare const recommendedTransformOrder: readonly ["stabilize-top-level-bindings", "stabilize-nested-bindings", "stabilize-deferred-top-level-bindings", "stabilize-deferred-stable-rhs", "expand-boolean-literals", "expand-sequence-expressions-v5", "expand-special-number-literals", "expand-typeof-undefined-comparisons", "expand-undefined-literals", "remove-redundant-else", "rename-arguments-length-flags", "rename-asap-wrappers", "rename-awaiter-parameters", "rename-awaiter-helper-functions", "rename-buffer-variables", "rename-to-buffer-results", "rename-catch-parameters", "rename-promise-catch-parameters", "rename-char-code-at", "rename-charcode-variables-v2", "rename-client-aliases", "rename-comparison-flags", "rename-date-now-start-times", "rename-default-options-parameters", "rename-deferred-resolve-parameters", "rename-destructured-aliases", "rename-rest-parameters", "rename-execfile-arguments", "rename-error-first-callback-parameters", "rename-error-variables", "rename-event-parameters", "rename-http-server-parameters", "rename-fs-sync-variables", "rename-http-method-parameters", "rename-interval-ids", "rename-loop-index-variables-v3", "rename-loop-length-variables", "rename-document-fragment-variables", "rename-object-keys-variables", "rename-object-keys-iterator-variables", "rename-parameters-to-match-properties-v2", "rename-promise-executor-parameters-v2", "rename-range-parameters", "rename-read-file-lines", "rename-regex-builders", "rename-search-parameters-variables", "rename-string-split-variables", "rename-this-aliases", "rename-timeout-ids", "rename-typeof-variables", "rename-typescript-helper-aliases", "rename-uint8array-concat-variables", "rename-url-parameters", "rename-url-variables", "rename-use-reference-guards-v2", "rename-use-reference-sets", "rename-worker-handles", "simplify-boolean-negations", "simplify-string-trim", "split-variable-declarations", "use-optional-chaining", "use-object-property-shorthand", "use-object-shorthand", "replace-dynamic-require-eval"];

package/dist/transforms/recommended-transform-order.js

@@ -8,6 +8,16 @@ export const recommendedTransformOrder = [
     // Run first: gives all bindings stable names before other transforms run.
     // Re-parses AST after renaming so subsequent transforms get fresh scope bindings.
     "stabilize-top-level-bindings",
+    // Run second: stabilizes local bindings inside CommonJS factory callbacks.
+    // Depends on stabilize-top-level-bindings having renamed factory wrapper functions to $h_*.
+    "stabilize-nested-bindings",
+    // Run third: stabilizes top-level vars that are assigned inside stable-named functions.
+    // Depends on stabilize-top-level-bindings having renamed enclosing functions to $h_*.
+    "stabilize-deferred-top-level-bindings",
+    // Run fourth: stabilizes remaining deferred vars whose RHS has only stable identifiers.
+    // Depends on stabilize-top-level-bindings and stabilize-deferred-top-level-bindings
+    // having renamed identifiers to $h_*/$v_*.
+    "stabilize-deferred-stable-rhs",
     "expand-boolean-literals",
     "expand-sequence-expressions-v5",
     "expand-special-number-literals",

package/dist/transforms/stabilize-deferred-stable-rhs/check-rhs-stability.d.ts

@@ -0,0 +1,6 @@
+import type { Expression } from "@babel/types";
+/**
+ * Check if all identifier references in an expression are stable
+ * (globals or already-stabilized names).
+ */
+export declare const hasAllStableReferences: (expression: Expression, programScopeBindings: Set<string>) => boolean;

package/dist/transforms/stabilize-deferred-stable-rhs/check-rhs-stability.js

@@ -0,0 +1,51 @@
+import { isHashBasedStableName } from "../../core/stable-naming.js";
+/**
+ * Check if all identifier references in an expression are stable
+ * (globals or already-stabilized names).
+ */
+export const hasAllStableReferences = (expression, programScopeBindings) => {
+    const identifiers = collectIdentifierReferences(expression);
+    return identifiers.every((name) => isHashBasedStableName(name) || !programScopeBindings.has(name));
+};
+/**
+ * Collect all identifier references in an expression,
+ * skipping non-computed property keys in member expressions and object literals.
+ */
+const collectIdentifierReferences = (node) => {
+    if (!node || typeof node !== "object")
+        return [];
+    const astNode = node;
+    if (astNode.type === "Identifier")
+        return [astNode.name];
+    if ((astNode.type === "MemberExpression" ||
+        astNode.type === "OptionalMemberExpression") &&
+        !astNode.computed) {
+        return collectIdentifierReferences(astNode.object);
+    }
+    // Skip non-computed, non-shorthand ObjectProperty keys — they're labels, not references.
+    if (astNode.type === "ObjectProperty" &&
+        !astNode.computed &&
+        !astNode.shorthand) {
+        return collectIdentifierReferences(astNode.value);
+    }
+    const result = [];
+    for (const [key, value] of Object.entries(astNode)) {
+        if (key === "type" || key === "start" || key === "end" || key === "loc")
+            continue;
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                if (item &&
+                    typeof item === "object" &&
+                    item.type) {
+                    result.push(...collectIdentifierReferences(item));
+                }
+            }
+        }
+        else if (value &&
+            typeof value === "object" &&
+            value.type) {
+            result.push(...collectIdentifierReferences(value));
+        }
+    }
+    return result;
+};

package/dist/transforms/stabilize-deferred-stable-rhs/manifest.json

@@ -0,0 +1,13 @@
+{
+    "recommended": true,
+    "notes": "Stabilizes deferred top-level vars whose RHS contains only stable identifiers (globals or $h_/$f_/$v_ prefixed names). Derives names by hashing the RHS code. Complements stabilize-deferred-top-level-bindings by handling multi-var functions.",
+    "evaluations": {
+        "claude-code-2.1.10:claude-code-2.1.11": {
+            "diffSizePercent": 95.54,
+            "evaluatedAt": "2026-02-05T18:30:00.000Z",
+            "changedLines": 3730,
+            "durationSeconds": 30,
+            "stableNames": 1741
+        }
+    }
+}

package/dist/transforms/stabilize-deferred-stable-rhs/stabilize-deferred-stable-rhs-transform.d.ts

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

package/dist/transforms/stabilize-deferred-stable-rhs/stabilize-deferred-stable-rhs-transform.js

@@ -0,0 +1,125 @@
+import { createRequire } from "node:module";
+import { createHash } from "node:crypto";
+import { parse } from "@babel/parser";
+import * as t from "@babel/types";
+import { getFilesToProcess, } from "../../core/types.js";
+import { generateCode } from "../../cli/generate-code.js";
+import { isHashBasedStableName } from "../../core/stable-naming.js";
+import { canRenameBindingSafely, findEnclosingBindingName, renameBindingInPlace, } from "../stabilize-deferred-top-level-bindings/rename-helpers.js";
+import { hasAllStableReferences } from "./check-rhs-stability.js";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const traverse = require("@babel/traverse").default;
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const generate = require("@babel/generator").default;
+const hashCode = (code) => createHash("sha256").update(code).digest("hex").slice(0, 16);
+export const stabilizeDeferredStableRhsTransform = {
+    id: "stabilize-deferred-stable-rhs",
+    description: "Renames deferred top-level vars whose RHS contains only stable identifiers " +
+        "(globals or $h_/$f_/$v_ prefixed). Derives stable names by hashing the RHS code. " +
+        "Complements stabilize-deferred-top-level-bindings by handling multi-var functions.",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const fileInfo of getFilesToProcess(context)) {
+            const program = fileInfo.ast.program;
+            let programScope;
+            traverse(fileInfo.ast, {
+                Program(path) {
+                    programScope = path.scope;
+                    path.stop();
+                },
+            });
+            if (!programScope)
+                continue;
+            const programScopeBindings = new Set(Object.keys(programScope.bindings));
+            // Step 1: Find all uninitialized top-level vars that aren't already stable
+            const uninitializedVariables = new Set();
+            traverse(fileInfo.ast, {
+                VariableDeclaration(path) {
+                    nodesVisited++;
+                    if (path.parent.type !== "Program")
+                        return;
+                    if (path.node.kind !== "var")
+                        return;
+                    for (const declaration of path.node.declarations) {
+                        if (!declaration.init &&
+                            t.isIdentifier(declaration.id) &&
+                            !isHashBasedStableName(declaration.id.name)) {
+                            uninitializedVariables.add(declaration.id.name);
+                        }
+                    }
+                },
+            });
+            // Step 2: Find assignments inside stable-named functions
+            const assignments = [];
+            traverse(fileInfo.ast, {
+                AssignmentExpression(path) {
+                    nodesVisited++;
+                    if (!t.isIdentifier(path.node.left))
+                        return;
+                    const variableName = path.node.left.name;
+                    if (!uninitializedVariables.has(variableName))
+                        return;
+                    const functionPath = path.findParent((p) => p.isFunction());
+                    if (!functionPath)
+                        return;
+                    const enclosingFunctionName = findEnclosingBindingName(functionPath);
+                    if (!enclosingFunctionName ||
+                        !isHashBasedStableName(enclosingFunctionName))
+                        return;
+                    // Check stability and capture RHS code NOW, before any renames happen.
+                    // This prevents order-dependent cascading where renaming one var
+                    // makes another var's RHS appear stable.
+                    const rhsNode = path.node.right;
+                    const isStable = hasAllStableReferences(rhsNode, programScopeBindings);
+                    assignments.push({
+                        variableName,
+                        rhsNode,
+                        enclosingFunctionName,
+                        rhsCode: isStable
+                            ? generate(rhsNode, { concise: true }).code
+                            : undefined,
+                    });
+                },
+            });
+            // Step 3: Apply renames for assignments with all-stable RHS.
+            // Deduplicate by variable name — if a var has multiple assignments,
+            // use only the first (order is AST traversal order).
+            // Track used target names to prevent collisions: two vars with identical
+            // RHS code produce the same hash, and renameBindingInPlace does not update
+            // Babel's scope map, so canRenameBindingSafely would not catch the second.
+            const seen = new Set();
+            const usedNewNames = new Set();
+            let fileTransformations = 0;
+            for (const { variableName, rhsCode } of assignments) {
+                if (!rhsCode)
+                    continue;
+                if (seen.has(variableName))
+                    continue;
+                seen.add(variableName);
+                const newName = `$v_${hashCode(rhsCode)}`;
+                if (usedNewNames.has(newName))
+                    continue;
+                if (!canRenameBindingSafely(programScope, variableName, newName))
+                    continue;
+                if (renameBindingInPlace(programScope, variableName, newName)) {
+                    usedNewNames.add(newName);
+                    fileTransformations++;
+                }
+            }
+            transformationsApplied += fileTransformations;
+            if (fileTransformations > 0) {
+                const code = generateCode(fileInfo.ast);
+                const newAst = parse(code, {
+                    sourceType: program.sourceType,
+                    plugins: ["jsx", "typescript"],
+                });
+                fileInfo.ast = newAst;
+            }
+        }
+        return Promise.resolve({ nodesVisited, transformationsApplied });
+    },
+};

package/dist/transforms/stabilize-deferred-top-level-bindings/collect-deferred-variables.d.ts

@@ -0,0 +1,22 @@
+import type { Scope } from "@babel/traverse";
+import * as t from "@babel/types";
+type DeferredVariableInfo = {
+    variableName: string;
+    enclosingFunctionName: string;
+    scope: Scope;
+};
+/**
+ * Collect information about deferred top-level var declarations.
+ * A "deferred var" is declared at top-level without an initializer,
+ * then assigned inside a function.
+ */
+export declare const collectDeferredVariables: (ast: t.File, programScope: Scope) => {
+    deferredVariables: DeferredVariableInfo[];
+    nodesVisited: number;
+};
+/**
+ * Group deferred vars by their enclosing function.
+ * Returns only vars where the function has exactly ONE deferred var.
+ */
+export declare const filterToSingleVariableFunctions: (deferredVariables: DeferredVariableInfo[]) => DeferredVariableInfo[];
+export {};

package/dist/transforms/stabilize-deferred-top-level-bindings/collect-deferred-variables.js

@@ -0,0 +1,115 @@
+import { createRequire } from "node:module";
+import * as t from "@babel/types";
+import { isHashBasedStableName } from "../../core/stable-naming.js";
+import { findEnclosingBindingName } from "./rename-helpers.js";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const traverse = require("@babel/traverse").default;
+/**
+ * Collect information about deferred top-level var declarations.
+ * A "deferred var" is declared at top-level without an initializer,
+ * then assigned inside a function.
+ */
+export const collectDeferredVariables = (ast, programScope) => {
+    let nodesVisited = 0;
+    // Step 1: Find all top-level var declarations without initializers
+    const uninitializedVariables = new Set();
+    traverse(ast, {
+        VariableDeclaration(path) {
+            nodesVisited++;
+            if (path.parent.type !== "Program")
+                return;
+            if (path.node.kind !== "var")
+                return;
+            for (const decl of path.node.declarations) {
+                if (!decl.init && t.isIdentifier(decl.id)) {
+                    uninitializedVariables.add(decl.id.name);
+                }
+            }
+        },
+    });
+    // Step 2: Find assignments to these vars and track which function they're in
+    const variableAssignments = new Map();
+    traverse(ast, {
+        AssignmentExpression(path) {
+            nodesVisited++;
+            if (!t.isIdentifier(path.node.left))
+                return;
+            const variableName = path.node.left.name;
+            if (!uninitializedVariables.has(variableName))
+                return;
+            // Find enclosing function
+            const functionPath = path.findParent((p) => p.isFunction());
+            if (!functionPath) {
+                // Top-level assignment — mark as unsuitable. Preserve count from any
+                // earlier function-scoped assignment so the step-3 filter stays correct.
+                const existing = variableAssignments.get(variableName);
+                variableAssignments.set(variableName, {
+                    enclosingFunctionName: undefined,
+                    count: (existing?.count ?? 0) + 1,
+                });
+                return;
+            }
+            // Get the enclosing function's binding name
+            const functionName = findEnclosingBindingName(functionPath);
+            const existing = variableAssignments.get(variableName);
+            if (existing) {
+                existing.count++;
+                // If assigned in different functions or multiple times, mark as unsuitable
+                if (existing.enclosingFunctionName !== functionName) {
+                    existing.enclosingFunctionName = undefined;
+                }
+            }
+            else {
+                variableAssignments.set(variableName, {
+                    enclosingFunctionName: functionName,
+                    count: 1,
+                });
+            }
+        },
+    });
+    // Step 3: Filter to vars that:
+    // - Have exactly one assignment
+    // - Are assigned inside a function with a stable name
+    const deferredVariables = [];
+    for (const [variableName, info] of variableAssignments) {
+        if (info.count === 1 &&
+            info.enclosingFunctionName &&
+            isHashBasedStableName(info.enclosingFunctionName)) {
+            const binding = programScope.getBinding(variableName);
+            if (binding) {
+                deferredVariables.push({
+                    variableName,
+                    enclosingFunctionName: info.enclosingFunctionName,
+                    scope: binding.scope,
+                });
+            }
+        }
+    }
+    return { deferredVariables, nodesVisited };
+};
+/**
+ * Group deferred vars by their enclosing function.
+ * Returns only vars where the function has exactly ONE deferred var.
+ */
+export const filterToSingleVariableFunctions = (deferredVariables) => {
+    // Group by enclosing function
+    const byFunction = new Map();
+    for (const info of deferredVariables) {
+        const existing = byFunction.get(info.enclosingFunctionName);
+        if (existing) {
+            existing.push(info);
+        }
+        else {
+            byFunction.set(info.enclosingFunctionName, [info]);
+        }
+    }
+    // Only keep vars where function has exactly one
+    const result = [];
+    for (const variables of byFunction.values()) {
+        if (variables.length === 1 && variables[0]) {
+            result.push(variables[0]);
+        }
+    }
+    return result;
+};

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

@@ -0,0 +1,13 @@
+{
+    "recommended": true,
+    "notes": "Stabilizes top-level var declarations that are initialized inside stable-named functions (lazy init pattern). Only applies when the enclosing function has exactly one such deferred var to avoid order-dependent naming. Renames ~750 vars but diff reduction is minimal (0.03%) because most vars already have consistent minified names between versions. The stabilization helps when minifiers do vary names.",
+    "evaluations": {
+        "claude-code-2.1.10:claude-code-2.1.11": {
+            "diffSizePercent": 99.97,
+            "evaluatedAt": "2026-02-05T17:32:00.000Z",
+            "changedLines": 753,
+            "durationSeconds": 26,
+            "stableNames": 2110
+        }
+    }
+}

package/dist/transforms/stabilize-deferred-top-level-bindings/rename-helpers.d.ts

@@ -0,0 +1,24 @@
+import type { NodePath, Scope } from "@babel/traverse";
+/**
+ * Extract the hash suffix from a stable function name (`$h_` or `$f_` prefix).
+ * Does not match `$v_` names — those are deferred variables, not functions.
+ */
+export declare const extractHashFromStableName: (name: string) => string | undefined;
+/**
+ * Rename a binding by mutating AST nodes directly.
+ * Does NOT update Babel's internal scope bindings map — callers that rename
+ * multiple bindings in a loop must track used names externally
+ * (see `usedNewNames` in stabilize-deferred-stable-rhs) and re-parse
+ * afterwards to refresh scope state.
+ */
+export declare const renameBindingInPlace: (bindingScope: Scope, fromName: string, toName: string) => boolean;
+/**
+ * Check if we can safely rename a binding.
+ */
+export declare const canRenameBindingSafely: (bindingScope: Scope, fromName: string, toName: string) => boolean;
+/**
+ * Walk up the AST to find the binding name of the enclosing function.
+ * Handles `var $h_xxx = () => { ... }`, `$h_xxx = fn(() => { ... })`,
+ * and `function $h_xxx() { ... }`.
+ */
+export declare const findEnclosingBindingName: (path: NodePath) => string | undefined;

package/dist/transforms/stabilize-deferred-top-level-bindings/rename-helpers.js

@@ -0,0 +1,92 @@
+import * as t from "@babel/types";
+import { hasShadowingRisk } from "../../core/has-shadowing-risk.js";
+/**
+ * Extract the hash suffix from a stable function name (`$h_` or `$f_` prefix).
+ * Does not match `$v_` names — those are deferred variables, not functions.
+ */
+export const extractHashFromStableName = (name) => {
+    const match = name.match(/^\$[fh]_(.+)$/u);
+    return match?.[1];
+};
+/**
+ * Rename a binding by mutating AST nodes directly.
+ * Does NOT update Babel's internal scope bindings map — callers that rename
+ * multiple bindings in a loop must track used names externally
+ * (see `usedNewNames` in stabilize-deferred-stable-rhs) and re-parse
+ * afterwards to refresh scope state.
+ */
+export const renameBindingInPlace = (bindingScope, fromName, toName) => {
+    const binding = bindingScope.getBinding(fromName);
+    if (!binding)
+        return false;
+    // Rename the declaration site
+    binding.identifier.name = toName;
+    // Rename all references (Identifier and JSXIdentifier)
+    for (const referencePath of binding.referencePaths) {
+        if (t.isIdentifier(referencePath.node, { name: fromName })) {
+            referencePath.node.name = toName;
+        }
+        else if (t.isJSXIdentifier(referencePath.node, { name: fromName })) {
+            referencePath.node.name = toName;
+        }
+    }
+    // Rename mutation sites (assignments, updates, for-in/of)
+    for (const violationPath of binding.constantViolations) {
+        const node = violationPath.node;
+        if (t.isAssignmentExpression(node) &&
+            t.isIdentifier(node.left, { name: fromName })) {
+            node.left.name = toName;
+        }
+        else if (t.isUpdateExpression(node) &&
+            t.isIdentifier(node.argument, { name: fromName })) {
+            node.argument.name = toName;
+        }
+        else if ((t.isForInStatement(node) || t.isForOfStatement(node)) &&
+            t.isIdentifier(node.left, { name: fromName })) {
+            node.left.name = toName;
+        }
+    }
+    return true;
+};
+/**
+ * Check if we can safely rename a binding.
+ */
+export const canRenameBindingSafely = (bindingScope, fromName, toName) => {
+    if (fromName === toName)
+        return false;
+    if (bindingScope.hasOwnBinding(toName))
+        return false;
+    const programScope = bindingScope.getProgramParent();
+    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;
+};
+/**
+ * Walk up the AST to find the binding name of the enclosing function.
+ * Handles `var $h_xxx = () => { ... }`, `$h_xxx = fn(() => { ... })`,
+ * and `function $h_xxx() { ... }`.
+ */
+export const findEnclosingBindingName = (path) => {
+    // FunctionDeclaration: the path itself carries the id
+    if (path.isFunctionDeclaration() && path.node.id) {
+        return path.node.id.name;
+    }
+    let current = path.parentPath;
+    while (current) {
+        if (current.isVariableDeclarator() && t.isIdentifier(current.node.id)) {
+            return current.node.id.name;
+        }
+        if (current.isAssignmentExpression() && t.isIdentifier(current.node.left)) {
+            return current.node.left.name;
+        }
+        if (current.isProgram())
+            break;
+        current = current.parentPath;
+    }
+    return undefined;
+};

package/dist/transforms/stabilize-deferred-top-level-bindings/stabilize-deferred-top-level-bindings-transform.d.ts

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

package/dist/transforms/stabilize-deferred-top-level-bindings/stabilize-deferred-top-level-bindings-transform.js

@@ -0,0 +1,68 @@
+import { createRequire } from "node:module";
+import { parse } from "@babel/parser";
+import { getFilesToProcess, } from "../../core/types.js";
+import { generateCode } from "../../cli/generate-code.js";
+import { collectDeferredVariables, filterToSingleVariableFunctions, } from "./collect-deferred-variables.js";
+import { canRenameBindingSafely, extractHashFromStableName, renameBindingInPlace, } from "./rename-helpers.js";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const traverse = require("@babel/traverse").default;
+export const stabilizeDeferredTopLevelBindingsTransform = {
+    id: "stabilize-deferred-top-level-bindings",
+    description: "Renames top-level var declarations without initializers (deferred bindings) to stable names " +
+        "derived from their enclosing stable function. Only applies when the function has exactly one " +
+        "such deferred var to avoid order-dependent naming.",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const fileInfo of getFilesToProcess(context)) {
+            const program = fileInfo.ast.program;
+            // Get program scope
+            let programScope;
+            traverse(fileInfo.ast, {
+                Program(path) {
+                    programScope = path.scope;
+                    path.stop();
+                },
+            });
+            if (!programScope)
+                continue;
+            // Collect deferred vars
+            const { deferredVariables, nodesVisited: fileNodesVisited } = collectDeferredVariables(fileInfo.ast, programScope);
+            nodesVisited += fileNodesVisited;
+            // Filter to vars where function has exactly one deferred var
+            const eligibleVariables = filterToSingleVariableFunctions(deferredVariables);
+            // Apply renames. Track used names for consistency with stabilize-deferred-stable-rhs,
+            // even though collisions are structurally prevented by unique enclosing function names.
+            const usedNewNames = new Set();
+            let fileTransformations = 0;
+            for (const { variableName, enclosingFunctionName, scope, } of eligibleVariables) {
+                const hash = extractHashFromStableName(enclosingFunctionName);
+                if (!hash)
+                    continue;
+                const newName = `$v_${hash}`;
+                if (usedNewNames.has(newName))
+                    continue;
+                if (!canRenameBindingSafely(scope, variableName, newName))
+                    continue;
+                if (renameBindingInPlace(scope, variableName, newName)) {
+                    usedNewNames.add(newName);
+                    fileTransformations++;
+                }
+            }
+            transformationsApplied += fileTransformations;
+            // Re-parse the AST to refresh Babel's scope bindings for subsequent transforms
+            if (fileTransformations > 0) {
+                const code = generateCode(fileInfo.ast);
+                const newAst = parse(code, {
+                    sourceType: program.sourceType,
+                    plugins: ["jsx", "typescript"],
+                });
+                fileInfo.ast = newAst;
+            }
+        }
+        return Promise.resolve({ nodesVisited, transformationsApplied });
+    },
+};

package/dist/transforms/stabilize-nested-bindings/apply-renames.d.ts

@@ -0,0 +1,9 @@
+import type { RenameCandidate } from "./collect-factory-bindings.js";
+/**
+ * Applies renames to candidates, handling hash collisions with index suffixes.
+ *
+ * Uses `scope.rename()` which invalidates Babel's scope internals after renaming.
+ * The caller must re-parse the AST after all renames are applied to refresh scope
+ * bindings for subsequent transforms (see stabilize-nested-bindings-transform.ts).
+ */
+export declare const applyRenames: (candidates: RenameCandidate[]) => number;

package/dist/transforms/stabilize-nested-bindings/apply-renames.js

@@ -0,0 +1,50 @@
+import { hasShadowingRisk } from "../../core/has-shadowing-risk.js";
+const NESTED_STABLE_PREFIX = "$f_";
+/**
+ * Applies renames to candidates, handling hash collisions with index suffixes.
+ *
+ * Uses `scope.rename()` which invalidates Babel's scope internals after renaming.
+ * The caller must re-parse the AST after all renames are applied to refresh scope
+ * bindings for subsequent transforms (see stabilize-nested-bindings-transform.ts).
+ */
+export const applyRenames = (candidates) => {
+    // Group by hash to handle collisions
+    const hashGroups = new Map();
+    for (const candidate of candidates) {
+        const group = hashGroups.get(candidate.hash);
+        if (group) {
+            group.push(candidate);
+        }
+        else {
+            hashGroups.set(candidate.hash, [candidate]);
+        }
+    }
+    let transformationsApplied = 0;
+    for (const [hash, group] of hashGroups) {
+        for (let index = 0; index < group.length; index++) {
+            const candidate = group[index];
+            if (!candidate)
+                continue;
+            // Determine new name: $f_<hash> for unique, $f_<hash>_<index> for collisions
+            const newName = group.length === 1
+                ? `${NESTED_STABLE_PREFIX}${hash}`
+                : `${NESTED_STABLE_PREFIX}${hash}_${index}`;
+            // Skip if name already matches
+            if (candidate.name === newName)
+                continue;
+            // Check if new name is safe (no collision in current scope)
+            if (candidate.scope.hasOwnBinding(newName))
+                continue;
+            // Check for shadowing risk in nested scopes
+            const binding = candidate.scope.getBinding(candidate.name);
+            if (!binding)
+                continue;
+            if (hasShadowingRisk(binding, candidate.scope, newName))
+                continue;
+            // Apply the rename
+            candidate.scope.rename(candidate.name, newName);
+            transformationsApplied++;
+        }
+    }
+    return transformationsApplied;
+};

package/dist/transforms/stabilize-nested-bindings/collect-factory-bindings.d.ts

@@ -0,0 +1,11 @@
+import type { NodePath, Scope } from "@babel/traverse";
+import type { ArrowFunctionExpression, FunctionExpression } from "@babel/types";
+export type RenameCandidate = {
+    name: string;
+    hash: string;
+    scope: Scope;
+};
+/**
+ * Collects local binding candidates from a factory callback body.
+ */
+export declare const collectFactoryBindings: (functionPath: NodePath<FunctionExpression | ArrowFunctionExpression>) => RenameCandidate[];

package/dist/transforms/stabilize-nested-bindings/collect-factory-bindings.js

@@ -0,0 +1,72 @@
+import * as t from "@babel/types";
+import { isStableRenamed } from "../../core/stable-naming.js";
+import { hashFingerprintNode } from "../../core/fingerprint/hash-fingerprint-node.js";
+/**
+ * Collects local binding candidates from a factory callback body.
+ */
+export const collectFactoryBindings = (functionPath) => {
+    const candidates = [];
+    const seenNames = new Set();
+    const functionScope = functionPath.scope;
+    // Get the function body
+    const body = functionPath.node.body;
+    if (!t.isBlockStatement(body))
+        return candidates;
+    // Traverse only the immediate function scope (don't recurse into nested functions)
+    functionPath.traverse({
+        VariableDeclarator(path) {
+            const id = path.node.id;
+            if (!t.isIdentifier(id))
+                return;
+            const name = id.name;
+            // Only process bindings that belong to the factory's scope
+            // (var declarations in nested blocks are hoisted to function scope)
+            if (path.scope.getBinding(name)?.scope !== functionScope)
+                return;
+            if (isStableRenamed(name))
+                return;
+            if (seenNames.has(name))
+                return;
+            // Must have an initializer to hash
+            const init = path.node.init;
+            if (!init)
+                return;
+            seenNames.add(name);
+            const hash = hashFingerprintNode(init);
+            candidates.push({ name, hash, scope: functionScope });
+        },
+        FunctionDeclaration(path) {
+            // Only process bindings in the factory's immediate scope
+            if (path.scope.parent !== functionScope)
+                return;
+            const id = path.node.id;
+            if (!id)
+                return;
+            const name = id.name;
+            if (isStableRenamed(name))
+                return;
+            if (seenNames.has(name))
+                return;
+            seenNames.add(name);
+            const hash = hashFingerprintNode(path.node);
+            candidates.push({ name, hash, scope: functionScope });
+        },
+        ClassDeclaration(path) {
+            // Only process bindings in the factory's immediate scope
+            if (path.scope.parent !== functionScope)
+                return;
+            const id = path.node.id;
+            if (!id)
+                return;
+            const name = id.name;
+            if (isStableRenamed(name))
+                return;
+            if (seenNames.has(name))
+                return;
+            seenNames.add(name);
+            const hash = hashFingerprintNode(path.node);
+            candidates.push({ name, hash, scope: functionScope });
+        },
+    });
+    return candidates;
+};

package/dist/transforms/stabilize-nested-bindings/has-dynamic-name-lookup.d.ts

@@ -0,0 +1,12 @@
+import type { NodePath } from "@babel/traverse";
+import type { ArrowFunctionExpression, FunctionExpression } from "@babel/types";
+/**
+ * Checks if a function contains patterns that perform dynamic name lookup
+ * (eval, with, etc.) which would make local binding renames unsafe.
+ *
+ * For local/nested bindings, only direct eval and with statements can observe
+ * local scope. Indirect eval, Function(), and string timers run in global scope
+ * and cannot see local bindings—but we're conservative and flag any eval-like
+ * pattern to avoid breaking bundles that use these features.
+ */
+export declare const hasDynamicNameLookup: (functionPath: NodePath<FunctionExpression | ArrowFunctionExpression>) => boolean;

package/dist/transforms/stabilize-nested-bindings/has-dynamic-name-lookup.js

@@ -0,0 +1,49 @@
+import * as t from "@babel/types";
+import { isEvalLikeCallCallee } from "../dynamic-name-lookup/eval-like-call-detection.js";
+/**
+ * Checks if a function contains patterns that perform dynamic name lookup
+ * (eval, with, etc.) which would make local binding renames unsafe.
+ *
+ * For local/nested bindings, only direct eval and with statements can observe
+ * local scope. Indirect eval, Function(), and string timers run in global scope
+ * and cannot see local bindings—but we're conservative and flag any eval-like
+ * pattern to avoid breaking bundles that use these features.
+ */
+export const hasDynamicNameLookup = (functionPath) => {
+    let found = false;
+    functionPath.traverse({
+        WithStatement(_path) {
+            found = true;
+            _path.stop();
+        },
+        ReferencedIdentifier(path) {
+            if (found)
+                return;
+            if (!t.isIdentifier(path.node, { name: "eval" }))
+                return;
+            // A locally-bound `eval` isn't necessarily the builtin eval function,
+            // so only bail on *free* `eval` references.
+            if (path.scope.getBinding("eval"))
+                return;
+            found = true;
+            path.stop();
+        },
+        CallExpression(path) {
+            if (found)
+                return;
+            if (isEvalLikeCallCallee(path.node.callee, path.scope)) {
+                found = true;
+                path.stop();
+            }
+        },
+        OptionalCallExpression(path) {
+            if (found)
+                return;
+            if (isEvalLikeCallCallee(path.node.callee, path.scope)) {
+                found = true;
+                path.stop();
+            }
+        },
+    });
+    return found;
+};

package/dist/transforms/stabilize-nested-bindings/is-factory-callback.d.ts

@@ -0,0 +1,6 @@
+import type { ArrowFunctionExpression, FunctionExpression } from "@babel/types";
+/**
+ * Checks if a function looks like a CommonJS factory callback.
+ * Heuristic: 1-2 parameters with the first being an identifier (e.g., exports, module).
+ */
+export declare const isFactoryCallback: (callback: FunctionExpression | ArrowFunctionExpression) => boolean;

package/dist/transforms/stabilize-nested-bindings/is-factory-callback.js

@@ -0,0 +1,11 @@
+import * as t from "@babel/types";
+/**
+ * Checks if a function looks like a CommonJS factory callback.
+ * Heuristic: 1-2 parameters with the first being an identifier (e.g., exports, module).
+ */
+export const isFactoryCallback = (callback) => {
+    const parameters = callback.params;
+    if (parameters.length === 0 || parameters.length > 2)
+        return false;
+    return t.isIdentifier(parameters[0]);
+};

package/dist/transforms/stabilize-nested-bindings/manifest.json

@@ -0,0 +1,13 @@
+{
+    "recommended": true,
+    "evaluations": {
+        "claude-code-2.1.10:claude-code-2.1.11": {
+            "diffSizePercent": 43.68,
+            "evaluatedAt": "2026-02-05T13:38:00.000Z",
+            "changedLines": 47159,
+            "durationSeconds": 60,
+            "stableNames": 14374
+        }
+    },
+    "notes": "Stabilizes local bindings inside CommonJS factory callbacks using content-hash naming ($f_<hash>). Must run AFTER stabilize-top-level-bindings. Combined with top-level stabilization, achieves 33.49% diff size (67% reduction from baseline)."
+}

package/dist/transforms/stabilize-nested-bindings/stabilize-nested-bindings-transform.d.ts

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

package/dist/transforms/stabilize-nested-bindings/stabilize-nested-bindings-transform.js

@@ -0,0 +1,75 @@
+import { createRequire } from "node:module";
+import { parse } from "@babel/parser";
+import * as t from "@babel/types";
+import { getFilesToProcess, } from "../../core/types.js";
+import { generateCode } from "../../cli/generate-code.js";
+import { applyRenames } from "./apply-renames.js";
+import { collectFactoryBindings } from "./collect-factory-bindings.js";
+import { hasDynamicNameLookup } from "./has-dynamic-name-lookup.js";
+import { isFactoryCallback } from "./is-factory-callback.js";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const traverse = require("@babel/traverse").default;
+/**
+ * Checks if a name looks like a stabilized top-level binding ($h_...)
+ */
+const isStabilizedTopLevel = (name) => {
+    return name.startsWith("$h_");
+};
+export const stabilizeNestedBindingsTransform = {
+    id: "stabilize-nested-bindings",
+    description: "Renames local bindings inside CommonJS factory callbacks to content-hash-based stable names ($f_<hash>). This stabilizes variable names that are randomly assigned by minifiers within factory functions.",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const fileInfo of getFilesToProcess(context)) {
+            let fileTransformations = 0;
+            traverse(fileInfo.ast, {
+                CallExpression(path) {
+                    nodesVisited++;
+                    // Check if callee is a stabilized top-level function ($h_...)
+                    const callee = path.node.callee;
+                    if (!t.isIdentifier(callee))
+                        return;
+                    if (!isStabilizedTopLevel(callee.name))
+                        return;
+                    // Check if first argument is a function (the factory callback)
+                    const callArguments = path.node.arguments;
+                    if (callArguments.length === 0)
+                        return;
+                    const firstArgument = callArguments[0];
+                    if (!t.isFunctionExpression(firstArgument) &&
+                        !t.isArrowFunctionExpression(firstArgument))
+                        return;
+                    // Verify it looks like a factory callback
+                    if (!isFactoryCallback(firstArgument))
+                        return;
+                    // Get the path to the function argument
+                    const functionArgumentPath = path.get("arguments.0");
+                    if (!functionArgumentPath.isFunctionExpression() &&
+                        !functionArgumentPath.isArrowFunctionExpression())
+                        return;
+                    // Skip renaming if factory contains dynamic name lookup (eval, with, etc.)
+                    if (hasDynamicNameLookup(functionArgumentPath))
+                        return;
+                    // Collect and rename local bindings
+                    const candidates = collectFactoryBindings(functionArgumentPath);
+                    fileTransformations += applyRenames(candidates);
+                },
+            });
+            transformationsApplied += fileTransformations;
+            // Re-parse if we made changes to refresh scope bindings
+            if (fileTransformations > 0) {
+                const code = generateCode(fileInfo.ast);
+                const newAst = parse(code, {
+                    sourceType: fileInfo.ast.program.sourceType,
+                    plugins: ["jsx", "typescript"],
+                });
+                fileInfo.ast = newAst;
+            }
+        }
+        return Promise.resolve({ nodesVisited, transformationsApplied });
+    },
+};

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

@@ -1,6 +1,6 @@
 import * as t from "@babel/types";
 import { isStableRenamed } from "../../core/stable-naming.js";
-import { hashFingerprintNode } from "./fingerprint-node.js";
+import { hashFingerprintNode } from "../../core/fingerprint/hash-fingerprint-node.js";
 import { collectFirstProgramBodyAssignments } from "./collect-first-program-body-assignments.js";
 import { collectNestedProgramScopeVariableInitializers } from "./collect-nested-program-scope-variable-initializers.js";
 import { addRenameCandidate } from "./rename-candidate.js";

package/package.json

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