miniread 1.67.0 → 1.68.0

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

@@ -6,6 +6,7 @@
  *
  * 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.
  *
  * - Stable names (`$timeoutId`): Readable AND deterministic across versions
  * - Readable names (`timeoutId`): Semantic but order-dependent

package/dist/core/stable-naming.js

@@ -6,6 +6,7 @@
  *
  * 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.
  *
  * - Stable names (`$timeoutId`): Readable AND deterministic across versions
  * - Readable names (`timeoutId`): Semantic but order-dependent

package/dist/transforms/_generated/manifest.js

@@ -334,6 +334,11 @@ 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-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 +376,7 @@ export const manifestEntries = Object.entries(transformRegistry)
     .toSorted((a, b) => a.id.localeCompare(b.id));
 export const recommendedTransformIds = [
     "stabilize-top-level-bindings",
+    "stabilize-nested-bindings",
     "expand-boolean-literals",
     "expand-sequence-expressions-v5",
     "expand-special-number-literals",

package/dist/transforms/_generated/registry.js

@@ -68,6 +68,7 @@ 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 { 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 +142,7 @@ export const transformRegistry = {
     [simplifyBooleanNegationsTransform.id]: simplifyBooleanNegationsTransform,
     [simplifyStringTrimTransform.id]: simplifyStringTrimTransform,
     [splitVariableDeclarationsTransform.id]: splitVariableDeclarationsTransform,
+    [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.48924670219602,
+        "notes": "Measured with baseline none: 33.49% 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", "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,9 @@ 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",
     "expand-boolean-literals",
     "expand-sequence-expressions-v5",
     "expand-special-number-literals",

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 "./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/fingerprint-leaf-node.d.ts

@@ -0,0 +1,2 @@
+import type { Node } from "@babel/types";
+export declare const fingerprintLeafNode: (node: Node) => string | undefined;

package/dist/transforms/stabilize-nested-bindings/fingerprint-leaf-node.js

@@ -0,0 +1,23 @@
+export const fingerprintLeafNode = (node) => {
+    // Normalize identifiers — this is the key operation that makes fingerprints
+    // stable across minified name changes.
+    if (node.type === "Identifier")
+        return "_";
+    if (node.type === "StringLiteral")
+        return `S:${JSON.stringify(node.value)}`;
+    if (node.type === "NumericLiteral")
+        return `N:${node.value}`;
+    if (node.type === "BooleanLiteral")
+        return `B:${node.value}`;
+    if (node.type === "NullLiteral")
+        return "NL";
+    if (node.type === "BigIntLiteral")
+        return `BI:${JSON.stringify(node.value)}`;
+    if (node.type === "RegExpLiteral")
+        return `R:${JSON.stringify(node.pattern)}:${JSON.stringify(node.flags)}`;
+    if (node.type === "TemplateElement")
+        return `T:${JSON.stringify(node.value.raw)}`;
+    if (node.type === "DirectiveLiteral")
+        return `D:${JSON.stringify(node.value)}`;
+    return undefined;
+};

package/dist/transforms/stabilize-nested-bindings/fingerprint-scalar-fields.d.ts

@@ -0,0 +1,2 @@
+import type { Node } from "@babel/types";
+export declare const fingerprintScalarFields: (node: Node) => string[];

package/dist/transforms/stabilize-nested-bindings/fingerprint-scalar-fields.js

@@ -0,0 +1,140 @@
+import * as t from "@babel/types";
+const encodeScalar = (value) => value === undefined ? "undefined" : JSON.stringify(value);
+export const fingerprintScalarFields = (node) => {
+    if (node.type === "AssignmentExpression" ||
+        node.type === "BinaryExpression" ||
+        node.type === "LogicalExpression" ||
+        node.type === "UnaryExpression") {
+        return [
+            `operator=${encodeScalar(node.operator)}`,
+        ];
+    }
+    if (node.type === "UpdateExpression") {
+        return [
+            `operator=${encodeScalar(node.operator)}`,
+            `prefix=${encodeScalar(node.prefix)}`,
+        ];
+    }
+    if (node.type === "MemberExpression" ||
+        node.type === "OptionalMemberExpression") {
+        const computed = node.computed;
+        const property = node
+            .property;
+        const propertyName = computed === false && t.isIdentifier(property)
+            ? property.name
+            : computed === false && t.isPrivateName(property)
+                ? `#${property.id.name}`
+                : undefined;
+        return [
+            `computed=${encodeScalar(computed)}`,
+            `optional=${encodeScalar(node.optional)}`,
+            `propertyName=${encodeScalar(propertyName)}`,
+        ];
+    }
+    if (node.type === "OptionalCallExpression") {
+        return [
+            `optional=${encodeScalar(node.optional)}`,
+        ];
+    }
+    if (node.type === "VariableDeclaration") {
+        return [
+            `kind=${encodeScalar(node.kind)}`,
+        ];
+    }
+    if (node.type === "FunctionDeclaration" ||
+        node.type === "FunctionExpression" ||
+        node.type === "ArrowFunctionExpression" ||
+        node.type === "ObjectMethod" ||
+        node.type === "ClassMethod" ||
+        node.type === "ClassPrivateMethod") {
+        const fields = [
+            `async=${encodeScalar(node.async)}`,
+            `generator=${encodeScalar(node.generator)}`,
+            `kind=${encodeScalar(node.kind)}`,
+            `static=${encodeScalar(node.static)}`,
+            `computed=${encodeScalar(node.computed)}`,
+        ];
+        if (node.type === "ObjectMethod") {
+            const computed = node.computed;
+            const key = node.key;
+            if (computed !== true) {
+                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") {
+            const computed = node.computed;
+            const key = node.key;
+            if (computed !== true) {
+                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 === "ObjectProperty") {
+        const computed = node.computed;
+        const key = node.key;
+        const fields = [`computed=${encodeScalar(computed)}`];
+        if (computed !== true) {
+            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;
+        return [
+            `static=${encodeScalar(node.static)}`,
+            `computed=${encodeScalar(computed)}`,
+            `keyName=${encodeScalar(keyName)}`,
+        ];
+    }
+    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 [];
+};

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/hash-fingerprint-node.d.ts

@@ -0,0 +1 @@
+export declare const hashFingerprintNode: (node: unknown) => string;

package/dist/transforms/stabilize-nested-bindings/hash-fingerprint-node.js

@@ -0,0 +1,9 @@
+import { createHash } from "node:crypto";
+import { writeFingerprintNode } from "./serialize-fingerprint-node.js";
+export const hashFingerprintNode = (node) => {
+    const hasher = createHash("sha256");
+    writeFingerprintNode(node, (text) => {
+        hasher.update(text);
+    });
+    return hasher.digest("hex").slice(0, 16);
+};

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,15 @@
+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;
+    // Check if first param is an identifier (exports or module.exports pattern)
+    const firstParameter = parameters[0];
+    if (!t.isIdentifier(firstParameter))
+        return false;
+    return true;
+};

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/serialize-fingerprint-node.d.ts

@@ -0,0 +1,3 @@
+type Writer = (text: string) => void;
+export declare const writeFingerprintNode: (value: unknown, write: Writer) => void;
+export {};

package/dist/transforms/stabilize-nested-bindings/serialize-fingerprint-node.js

@@ -0,0 +1,102 @@
+import * as t from "@babel/types";
+import { fingerprintLeafNode } from "./fingerprint-leaf-node.js";
+import { fingerprintScalarFields } from "./fingerprint-scalar-fields.js";
+const pushArrayTasks = (stack, value) => {
+    stack.push({ kind: "text", text: "]" });
+    for (let index = value.length - 1; index >= 0; index--) {
+        if (index < value.length - 1) {
+            stack.push({ kind: "text", text: "," });
+        }
+        stack.push({ kind: "value", value: value[index] });
+    }
+    stack.push({ kind: "text", text: "[" });
+};
+const pushNodeTasks = (stack, node) => {
+    const leaf = fingerprintLeafNode(node);
+    if (leaf !== undefined) {
+        stack.push({ kind: "text", text: leaf });
+        return;
+    }
+    const keys = t.VISITOR_KEYS[node.type];
+    if (!keys) {
+        stack.push({ kind: "text", text: node.type });
+        return;
+    }
+    let visitorKeys = keys;
+    const computed = node.computed;
+    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 }];
+    for (const field of fingerprintScalarFields(node)) {
+        nodeTasks.push({ kind: "text", text: field });
+    }
+    for (const key of visitorKeys) {
+        nodeTasks.push({
+            kind: "value",
+            value: node[key],
+        });
+    }
+    for (let index = nodeTasks.length - 1; index >= 0; index--) {
+        const nodeTask = nodeTasks[index];
+        if (!nodeTask)
+            continue;
+        stack.push(nodeTask);
+        if (index !== 0) {
+            stack.push({ kind: "text", text: "|" });
+        }
+    }
+};
+export const writeFingerprintNode = (value, write) => {
+    const stack = [{ kind: "value", value }];
+    while (stack.length > 0) {
+        const task = stack.pop();
+        if (!task)
+            break;
+        if (task.kind === "text") {
+            write(task.text);
+            continue;
+        }
+        const current = task.value;
+        if (current === null) {
+            write("null");
+            continue;
+        }
+        if (current === undefined) {
+            write("undefined");
+            continue;
+        }
+        if (typeof current === "string") {
+            write(JSON.stringify(current));
+            continue;
+        }
+        if (typeof current === "number" || typeof current === "boolean") {
+            write(String(current));
+            continue;
+        }
+        if (Array.isArray(current)) {
+            pushArrayTasks(stack, current);
+            continue;
+        }
+        if (typeof current !== "object") {
+            write(JSON.stringify(current));
+            continue;
+        }
+        const nodeCandidate = current;
+        if (!("type" in nodeCandidate)) {
+            write("{}");
+            continue;
+        }
+        if (nodeCandidate.type === "Identifier") {
+            write("_");
+            continue;
+        }
+        pushNodeTasks(stack, nodeCandidate);
+    }
+};

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/package.json

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