miniread 1.68.0 → 1.70.0

package/dist/{transforms/stabilize-nested-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" ||
@@ -20,6 +31,9 @@ export const fingerprintScalarFields = (node) => {
         const computed = node.computed;
         const property = node
             .property;
+        // Include non-computed property names to reduce collisions (e.g. `obj.foo` vs
+        // `obj.bar`). This trades some cross-build stability for fewer collisions if
+        // a toolchain mangles property names between builds.
         const propertyName = computed === false && t.isIdentifier(property)
             ? property.name
             : computed === false && t.isPrivateName(property)
@@ -47,6 +61,8 @@ export const fingerprintScalarFields = (node) => {
         node.type === "ObjectMethod" ||
         node.type === "ClassMethod" ||
         node.type === "ClassPrivateMethod") {
+        // Keep a uniform field set for all function-like nodes; some fields (e.g. `static`,
+        // `computed`, `kind`) only exist on specific node types and will be `undefined` otherwise.
         const fields = [
             `async=${encodeScalar(node.async)}`,
             `generator=${encodeScalar(node.generator)}`,
@@ -54,36 +70,13 @@ export const fingerprintScalarFields = (node) => {
             `static=${encodeScalar(node.static)}`,
             `computed=${encodeScalar(node.computed)}`,
         ];
-        if (node.type === "ObjectMethod") {
+        if (node.type === "ObjectMethod" ||
+            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)}`);
-            }
-        }
-        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)}`);
+                fields.push(`keyName=${encodeScalar(extractKeyName(key))}`);
             }
         }
         return fields;
@@ -93,33 +86,14 @@ export const fingerprintScalarFields = (node) => {
         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)}`);
+            fields.push(`keyName=${encodeScalar(extractKeyName(key))}`);
         }
         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)}`,
@@ -129,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

@@ -7,6 +7,8 @@
  * 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
@@ -17,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

@@ -7,6 +7,8 @@
  * 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
@@ -21,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

@@ -229,6 +229,10 @@ const manifestData = {
         notes: "Measured with baseline none: 0.00%. Added to recommended for readability.",
         evaluations: { "legacy:evaluation": { "evaluatedAt": "2026-01-25T20:09:26.721Z", "changedLines": 6, "durationSeconds": 0, "stableNames": 0, "diffSizePercent": 100 }, "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 100, "evaluatedAt": "2026-01-25T23:27:14.483Z", "changedLines": 6, "durationSeconds": 44.636690875, "stableNames": 1358 } },
     },
+    "rename-regex-source-parameters": {
+        recommended: true,
+        evaluations: { "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 100, "evaluatedAt": "2026-02-05T18:50:18.894Z", "changedLines": 312, "durationSeconds": 224.52329859600002, "stableNames": 1357 } },
+    },
     "rename-replace-child-parameters": {
         recommended: false,
         notes: "Measured with baseline none: 0.00%.",
@@ -334,6 +338,16 @@ 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).",
@@ -377,6 +391,8 @@ export const manifestEntries = Object.entries(transformRegistry)
 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",
@@ -418,6 +434,7 @@ export const recommendedTransformIds = [
     "rename-range-parameters",
     "rename-read-file-lines",
     "rename-regex-builders",
+    "rename-regex-source-parameters",
     "rename-search-parameters-variables",
     "rename-string-split-variables",
     "rename-this-aliases",

package/dist/transforms/_generated/registry.js

@@ -46,6 +46,7 @@ import { renamePromiseExecutorParametersV2Transform } from "../rename-promise-ex
 import { renameRangeParametersTransform } from "../rename-range-parameters/rename-range-parameters-transform.js";
 import { renameReadFileLinesTransform } from "../rename-read-file-lines/rename-read-file-lines-transform.js";
 import { renameRegexBuildersTransform } from "../rename-regex-builders/rename-regex-builders-transform.js";
+import { renameRegexSourceParametersTransform } from "../rename-regex-source-parameters/rename-regex-source-parameters-transform.js";
 import { renameReplaceChildParametersTransform } from "../rename-replace-child-parameters/rename-replace-child-parameters-transform.js";
 import { renameRestParametersTransform } from "../rename-rest-parameters/rename-rest-parameters-transform.js";
 import { renameSafePropertyAccessorParametersTransform } from "../rename-safe-property-accessor-parameters/rename-safe-property-accessor-parameters-transform.js";
@@ -68,6 +69,8 @@ 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";
@@ -120,6 +123,7 @@ export const transformRegistry = {
     [renameRangeParametersTransform.id]: renameRangeParametersTransform,
     [renameReadFileLinesTransform.id]: renameReadFileLinesTransform,
     [renameRegexBuildersTransform.id]: renameRegexBuildersTransform,
+    [renameRegexSourceParametersTransform.id]: renameRegexSourceParametersTransform,
     [renameReplaceChildParametersTransform.id]: renameReplaceChildParametersTransform,
     [renameRestParametersTransform.id]: renameRestParametersTransform,
     [renameSafePropertyAccessorParametersTransform.id]: renameSafePropertyAccessorParametersTransform,
@@ -142,6 +146,8 @@ 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,

package/dist/transforms/preset-stats.json

@@ -1,6 +1,6 @@
 {
     "recommended": {
-        "diffSizePercent": 33.48924670219602,
-        "notes": "Measured with baseline none: 33.49% of original diff."
+        "diffSizePercent": 33.4134388841768,
+        "notes": "Measured with baseline none: 33.41% 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", "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"];
+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-regex-source-parameters", "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

@@ -11,6 +11,13 @@ export const recommendedTransformOrder = [
     // 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",
@@ -55,6 +62,7 @@ export const recommendedTransformOrder = [
     "rename-range-parameters",
     "rename-read-file-lines",
     "rename-regex-builders",
+    "rename-regex-source-parameters",
     "rename-search-parameters-variables",
     "rename-string-split-variables",
     "rename-this-aliases",

package/dist/transforms/rename-regex-source-parameters/manifest.json

@@ -0,0 +1,12 @@
+{
+    "recommended": true,
+    "evaluations": {
+        "claude-code-2.1.10:claude-code-2.1.11": {
+            "diffSizePercent": 100,
+            "evaluatedAt": "2026-02-05T18:50:18.894Z",
+            "changedLines": 312,
+            "durationSeconds": 224.52329859600002,
+            "stableNames": 1357
+        }
+    }
+}

package/dist/transforms/rename-regex-source-parameters/rename-regex-source-parameters-transform.d.ts

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

package/dist/transforms/rename-regex-source-parameters/rename-regex-source-parameters-transform.js

@@ -0,0 +1,126 @@
+import { createRequire } from "node:module";
+import { RenameGroup } from "../../core/stable-naming.js";
+import { getFilesToProcess, } from "../../core/types.js";
+import * as t from "@babel/types";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const traverse = require("@babel/traverse").default;
+const PARAMETER_BASE_NAME = "pattern";
+const getReturnArgumentFromConsequent = (consequent) => {
+    if (t.isReturnStatement(consequent)) {
+        if (!consequent.argument)
+            return undefined;
+        return consequent.argument;
+    }
+    if (t.isBlockStatement(consequent) && consequent.body.length === 1) {
+        const statement = consequent.body[0];
+        if (statement && t.isReturnStatement(statement)) {
+            if (!statement.argument)
+                return undefined;
+            return statement.argument;
+        }
+    }
+    return undefined;
+};
+const matchesNegatedIdentifier = (test, name) => t.isUnaryExpression(test, { operator: "!" }) &&
+    t.isIdentifier(test.argument, { name });
+const matchesTypeofStringCheck = (test, name) => {
+    if (!t.isBinaryExpression(test))
+        return false;
+    if (test.operator !== "===" && test.operator !== "==")
+        return false;
+    const left = test.left;
+    const right = test.right;
+    const isTypeofIdentifier = (expression) => t.isUnaryExpression(expression, { operator: "typeof" }) &&
+        t.isIdentifier(expression.argument, { name });
+    const isStringLiteralString = (expression) => t.isStringLiteral(expression, { value: "string" });
+    return ((isTypeofIdentifier(left) && isStringLiteralString(right)) ||
+        (isStringLiteralString(left) && isTypeofIdentifier(right)));
+};
+const matchesRegexSourceNormalizer = (path) => {
+    if (path.node.params.length !== 1)
+        return undefined;
+    const parameter = path.node.params[0];
+    if (!parameter || !t.isIdentifier(parameter))
+        return undefined;
+    if (!t.isBlockStatement(path.node.body))
+        return undefined;
+    const statements = path.node.body.body;
+    if (statements.length !== 3)
+        return undefined;
+    const first = statements[0];
+    const second = statements[1];
+    const third = statements[2];
+    if (!first || !second || !third)
+        return undefined;
+    if (!t.isIfStatement(first))
+        return undefined;
+    if (!t.isIfStatement(second))
+        return undefined;
+    if (!t.isReturnStatement(third))
+        return undefined;
+    if (first.alternate || second.alternate)
+        return undefined;
+    if (!matchesNegatedIdentifier(first.test, parameter.name))
+        return undefined;
+    const firstReturnArgument = getReturnArgumentFromConsequent(first.consequent);
+    if (!firstReturnArgument || !t.isNullLiteral(firstReturnArgument)) {
+        return undefined;
+    }
+    if (!matchesTypeofStringCheck(second.test, parameter.name))
+        return undefined;
+    const secondReturnArgument = getReturnArgumentFromConsequent(second.consequent);
+    if (!secondReturnArgument)
+        return undefined;
+    if (!t.isIdentifier(secondReturnArgument, { name: parameter.name })) {
+        return undefined;
+    }
+    const finalReturnArgument = third.argument;
+    if (!finalReturnArgument)
+        return undefined;
+    if (!t.isMemberExpression(finalReturnArgument))
+        return undefined;
+    if (finalReturnArgument.computed)
+        return undefined;
+    if (!t.isIdentifier(finalReturnArgument.object, { name: parameter.name })) {
+        return undefined;
+    }
+    if (!t.isIdentifier(finalReturnArgument.property, { name: "source" })) {
+        return undefined;
+    }
+    return { parameterName: parameter.name };
+};
+export const renameRegexSourceParametersTransform = {
+    id: "rename-regex-source-parameters",
+    description: "Renames regex source normalizer parameters to $pattern when they accept string or RegExp inputs.",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const fileInfo of getFilesToProcess(context)) {
+            const group = new RenameGroup();
+            traverse(fileInfo.ast, {
+                Function(path) {
+                    nodesVisited++;
+                    const match = matchesRegexSourceNormalizer(path);
+                    if (!match)
+                        return;
+                    const binding = path.scope.getBinding(match.parameterName);
+                    if (!binding?.constant)
+                        return;
+                    group.add({
+                        scope: path.scope,
+                        currentName: match.parameterName,
+                        baseName: PARAMETER_BASE_NAME,
+                    });
+                },
+            });
+            transformationsApplied += group.apply();
+        }
+        return Promise.resolve({
+            nodesVisited,
+            transformationsApplied,
+        });
+    },
+};

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;