miniread 1.77.0 → 1.79.0

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

@@ -13,7 +13,7 @@
  * - Stable names (`$timeoutId`): Readable AND deterministic across versions
  * - Readable names (`timeoutId`): Semantic but order-dependent
  */
-import type { Scope } from "@babel/traverse";
+import type { Binding, Scope } from "@babel/traverse";
 /**
  * Returns true if the name has been stable-renamed (starts with $).
  * Transforms should skip variables with this prefix.
@@ -25,6 +25,11 @@ export declare const isStableRenamed: (name: string) => boolean;
  * stabilized by one of the hash-based stabilization transforms.
  */
 export declare const isHashBasedStableName: (name: string) => boolean;
+/**
+ * Returns true only when the exact stable name slot (`$${baseName}`) is
+ * available for this binding in the provided scope.
+ */
+export declare const canUseExactStableName: (scope: Scope, binding: Binding | undefined, currentName: string, baseName: string) => boolean;
 /**
  * Entry for a planned rename operation.
  */

package/dist/core/stable-naming.js

@@ -29,6 +29,23 @@ export const isStableRenamed = (name) => {
  * stabilized by one of the hash-based stabilization transforms.
  */
 export const isHashBasedStableName = (name) => name.startsWith("$h_") || name.startsWith("$f_") || name.startsWith("$v_");
+/**
+ * Returns true only when the exact stable name slot (`$${baseName}`) is
+ * available for this binding in the provided scope.
+ */
+export const canUseExactStableName = (scope, binding, currentName, baseName) => {
+    const candidateStable = makeStableName(baseName);
+    const programGlobals = getProgramValueGlobals(scope);
+    const stableTaken = candidateStable === currentName
+        ? false
+        : scope.hasBinding(candidateStable) ||
+            programGlobals.has(candidateStable);
+    if (stableTaken)
+        return false;
+    if (binding && hasShadowingRisk(binding, scope, candidateStable))
+        return false;
+    return true;
+};
 /**
  * Creates a stable name by adding the $ prefix.
  * Internal helper - prefer using RenameGroup which handles stability logic automatically.

package/dist/transforms/_generated/manifest.js

@@ -168,10 +168,19 @@ const manifestData = {
         recommended: true,
         evaluations: { "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 100, "evaluatedAt": "2026-02-04T12:54:37.434Z", "changedLines": 14, "durationSeconds": 231.553556391, "stableNames": 1358 } },
     },
+    "rename-indexeddb-request-variables": {
+        recommended: true,
+        evaluations: { "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 100, "evaluatedAt": "2026-02-06T14:48:25.555Z", "changedLines": 30, "durationSeconds": 226.960178979, "stableNames": 1358 } },
+    },
     "rename-interval-ids": {
         recommended: true,
         evaluations: { "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 100, "evaluatedAt": "2026-02-01T09:30:55.276Z", "changedLines": 58, "durationSeconds": 201.398360841, "stableNames": 1358 } },
     },
+    "rename-invalid-parameter-arguments": {
+        recommended: true,
+        notes: "Added to recommended for readability of invalidParameterError call sites.",
+        evaluations: { "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 99.99811516350957, "evaluatedAt": "2026-02-06T12:52:02.935Z", "changedLines": 452, "durationSeconds": 211.048545671, "stableNames": 1381 } },
+    },
     "rename-loop-index-variables": {
         recommended: false,
         notes: "Superseded by rename-loop-index-variables-v3.",
@@ -455,12 +464,14 @@ export const recommendedTransformIds = [
     "rename-fs-sync-variables",
     "rename-http-method-parameters",
     "rename-interval-ids",
+    "rename-indexeddb-request-variables",
     "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-invalid-parameter-arguments",
     "rename-promise-executor-parameters-v2",
     "rename-range-parameters",
     "rename-read-file-lines",

package/dist/transforms/_generated/registry.js

@@ -34,7 +34,9 @@ import { renameFileReaderVariablesTransform } from "../rename-file-reader-variab
 import { renameFsSyncVariablesTransform } from "../rename-fs-sync-variables/rename-fs-sync-variables-transform.js";
 import { renameHttpMethodParametersTransform } from "../rename-http-method-parameters/rename-http-method-parameters-transform.js";
 import { renameHttpServerParametersTransform } from "../rename-http-server-parameters/rename-http-server-parameters-transform.js";
+import { renameIndexeddbRequestVariablesTransform } from "../rename-indexeddb-request-variables/rename-indexeddb-request-variables-transform.js";
 import { renameIntervalIdsTransform } from "../rename-interval-ids/rename-interval-ids-transform.js";
+import { renameInvalidParameterArgumentsTransform } from "../rename-invalid-parameter-arguments/rename-invalid-parameter-arguments-transform.js";
 import { renameLoopIndexVariablesTransform } from "../rename-loop-index-variables/rename-loop-index-variables-transform.js";
 import { renameLoopIndexVariablesV2Transform } from "../rename-loop-index-variables-v2/rename-loop-index-variables-v2-transform.js";
 import { renameLoopIndexVariablesV3Transform } from "../rename-loop-index-variables-v3/rename-loop-index-variables-v3-transform.js";
@@ -117,7 +119,9 @@ export const transformRegistry = {
     [renameFsSyncVariablesTransform.id]: renameFsSyncVariablesTransform,
     [renameHttpMethodParametersTransform.id]: renameHttpMethodParametersTransform,
     [renameHttpServerParametersTransform.id]: renameHttpServerParametersTransform,
+    [renameIndexeddbRequestVariablesTransform.id]: renameIndexeddbRequestVariablesTransform,
     [renameIntervalIdsTransform.id]: renameIntervalIdsTransform,
+    [renameInvalidParameterArgumentsTransform.id]: renameInvalidParameterArgumentsTransform,
     [renameLoopIndexVariablesTransform.id]: renameLoopIndexVariablesTransform,
     [renameLoopIndexVariablesV2Transform.id]: renameLoopIndexVariablesV2Transform,
     [renameLoopIndexVariablesV3Transform.id]: renameLoopIndexVariablesV3Transform,

package/dist/transforms/get-binding-stable-start.d.ts

@@ -0,0 +1,2 @@
+import type { Binding } from "@babel/traverse";
+export declare const getBindingStableStart: (binding: Binding) => number;

package/dist/transforms/get-binding-stable-start.js

@@ -0,0 +1,11 @@
+const BINDING_INDEX_SCALE = 1_000_000;
+export const getBindingStableStart = (binding) => {
+    const start = binding.identifier.start;
+    if (typeof start === "number")
+        return start;
+    const location = binding.identifier.loc;
+    if (location) {
+        return location.start.line * BINDING_INDEX_SCALE + location.start.column;
+    }
+    return Number.MAX_SAFE_INTEGER;
+};

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", "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-v2", "rename-deferred-resolve-parameters", "rename-destructured-aliases", "rename-rest-parameters", "rename-execfile-arguments", "rename-file-reader-variables", "rename-error-first-callback-parameters", "rename-error-first-callback-parameters-v2", "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-file-extension-variables", "rename-string-split-variables", "rename-this-aliases", "rename-timeout-promises", "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", "rename-zod-check-parameters", "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-v2", "rename-deferred-resolve-parameters", "rename-destructured-aliases", "rename-rest-parameters", "rename-execfile-arguments", "rename-file-reader-variables", "rename-error-first-callback-parameters", "rename-error-first-callback-parameters-v2", "rename-error-variables", "rename-event-parameters", "rename-http-server-parameters", "rename-fs-sync-variables", "rename-http-method-parameters", "rename-interval-ids", "rename-indexeddb-request-variables", "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-invalid-parameter-arguments", "rename-promise-executor-parameters-v2", "rename-range-parameters", "rename-read-file-lines", "rename-regex-builders", "rename-regex-source-parameters", "rename-search-parameters-variables", "rename-file-extension-variables", "rename-string-split-variables", "rename-this-aliases", "rename-timeout-promises", "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", "rename-zod-check-parameters", "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

@@ -54,12 +54,14 @@ export const recommendedTransformOrder = [
     "rename-fs-sync-variables",
     "rename-http-method-parameters",
     "rename-interval-ids",
+    "rename-indexeddb-request-variables",
     "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-invalid-parameter-arguments",
     "rename-promise-executor-parameters-v2",
     "rename-range-parameters",
     "rename-read-file-lines",

package/dist/transforms/rename-fs-sync-variables/rename-fs-sync-variables-transform.js

@@ -2,6 +2,7 @@ import { createRequire } from "node:module";
 import { collectExportedNames } from "../../core/collect-exported-names.js";
 import { isStableRenamed, RenameGroup } from "../../core/stable-naming.js";
 import { getFilesToProcess, } from "../../core/types.js";
+import { getBindingStableStart } from "../get-binding-stable-start.js";
 import { hasDynamicNameLookup } from "../has-dynamic-name-lookup.js";
 import { isNodeFileSystemNamespaceBinding } from "../is-node-file-system-identifier.js";
 const require = createRequire(import.meta.url);
@@ -56,15 +57,6 @@ const shouldRename = (identifier) => {
         return false;
     return true;
 };
-const getBindingStableStart = (binding) => {
-    const start = binding.identifier.start;
-    if (typeof start === "number")
-        return start;
-    const loc = binding.identifier.loc;
-    if (loc)
-        return loc.start.line * 1_000_000 + loc.start.column;
-    return Number.MAX_SAFE_INTEGER;
-};
 export const renameFsSyncVariablesTransform = {
     id: "rename-fs-sync-variables",
     description: "Renames Node fs bindings used with 2+ distinct fs.*Sync methods to stable fs-based names",

package/dist/transforms/rename-indexeddb-request-variables/analyze-indexeddb-request-binding.d.ts

@@ -0,0 +1,10 @@
+import type { Binding } from "@babel/traverse";
+import type { CallExpression, OptionalCallExpression } from "@babel/types";
+type RequestMethodName = "open" | "deleteDatabase";
+type RequestUsage = {
+    properties: Set<string>;
+};
+export declare const getIndexedDatabaseRequestInitMethod: (init: CallExpression | OptionalCallExpression) => RequestMethodName | undefined;
+export declare const getIndexedDBRequestUsage: (binding: Binding) => RequestUsage | undefined;
+export declare const hasOpenRequestSpecificSignals: (properties: Set<string>) => boolean;
+export {};

package/dist/transforms/rename-indexeddb-request-variables/analyze-indexeddb-request-binding.js

@@ -0,0 +1,86 @@
+const REQUEST_MEMBER_PROPERTIES = new Set([
+    "onerror",
+    "onsuccess",
+    "onblocked",
+    "onupgradeneeded",
+    "result",
+    "error",
+    "transaction",
+]);
+const OPEN_ONLY_SPECIFIC_PROPERTIES = new Set([
+    "onblocked",
+    "onupgradeneeded",
+    "transaction",
+]);
+const REQUEST_EVENT_HANDLER_PROPERTIES = new Set([
+    "onsuccess",
+    "onerror",
+    "onblocked",
+    "onupgradeneeded",
+]);
+const REQUEST_VALUE_PROPERTIES = new Set(["result", "error"]);
+const getMemberPropertyName = (member) => {
+    if (member.computed) {
+        if (member.property.type !== "StringLiteral")
+            return;
+        return member.property.value;
+    }
+    if (member.property.type !== "Identifier")
+        return;
+    return member.property.name;
+};
+export const getIndexedDatabaseRequestInitMethod = (init) => {
+    const callee = init.callee;
+    if (callee.type !== "MemberExpression" &&
+        callee.type !== "OptionalMemberExpression") {
+        return undefined;
+    }
+    const propertyName = getMemberPropertyName(callee);
+    if (!propertyName)
+        return undefined;
+    if (propertyName === "open")
+        return "open";
+    // `deleteDatabase` is distinctive enough that we intentionally avoid
+    // receiver-origin checks to preserve support for aliased IDB factories.
+    if (propertyName === "deleteDatabase")
+        return "deleteDatabase";
+    return undefined;
+};
+export const getIndexedDBRequestUsage = (binding) => {
+    const properties = new Set();
+    for (const referencePath of binding.referencePaths) {
+        // Be conservative: if any reference is not a direct request member access,
+        // skip renaming to avoid mislabeling generic `.open()` call results.
+        if (!referencePath.isIdentifier())
+            return;
+        const parentPath = referencePath.parentPath;
+        if (!parentPath.isMemberExpression() &&
+            !parentPath.isOptionalMemberExpression()) {
+            return;
+        }
+        const memberExpression = parentPath.node;
+        if (memberExpression.object !== referencePath.node)
+            return;
+        const propertyName = getMemberPropertyName(memberExpression);
+        if (!propertyName)
+            return;
+        if (!REQUEST_MEMBER_PROPERTIES.has(propertyName))
+            return;
+        properties.add(propertyName);
+    }
+    return { properties };
+};
+const hasAnyProperty = (properties, allowedProperties) => {
+    for (const property of properties) {
+        if (allowedProperties.has(property))
+            return true;
+    }
+    return false;
+};
+export const hasOpenRequestSpecificSignals = (properties) => 
+// `open()` is generic across APIs, so we require either IndexedDB-specific
+// signals (`onblocked`/`onupgradeneeded`/`transaction`) or the paired
+// request pattern (event callback + `result`/`error`) used by IDB requests.
+hasAnyProperty(properties, OPEN_ONLY_SPECIFIC_PROPERTIES) ||
+    (hasAnyProperty(properties, REQUEST_EVENT_HANDLER_PROPERTIES) &&
+        hasAnyProperty(properties, REQUEST_VALUE_PROPERTIES));

package/dist/transforms/rename-indexeddb-request-variables/manifest.json

@@ -0,0 +1,12 @@
+{
+    "recommended": true,
+    "evaluations": {
+        "claude-code-2.1.10:claude-code-2.1.11": {
+            "diffSizePercent": 100,
+            "evaluatedAt": "2026-02-06T14:48:25.555Z",
+            "changedLines": 30,
+            "durationSeconds": 226.960178979,
+            "stableNames": 1358
+        }
+    }
+}

package/dist/transforms/rename-indexeddb-request-variables/rename-indexeddb-request-variables-transform.d.ts

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

package/dist/transforms/rename-indexeddb-request-variables/rename-indexeddb-request-variables-transform.js

@@ -0,0 +1,100 @@
+import { createRequire } from "node:module";
+import { getIndexedDatabaseRequestInitMethod, getIndexedDBRequestUsage, hasOpenRequestSpecificSignals, } from "./analyze-indexeddb-request-binding.js";
+import { collectExportedNames } from "../../core/collect-exported-names.js";
+import { isStableRenamed, RenameGroup } from "../../core/stable-naming.js";
+import { getFilesToProcess, } from "../../core/types.js";
+import { getBindingStableStart } from "../get-binding-stable-start.js";
+import { hasDynamicNameLookup } from "../has-dynamic-name-lookup.js";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const traverse = require("@babel/traverse").default;
+const BASE_NAME = "dbRequest";
+const getRequestMethod = (init) => {
+    if (init?.type !== "CallExpression" &&
+        init?.type !== "OptionalCallExpression") {
+        return undefined;
+    }
+    return getIndexedDatabaseRequestInitMethod(init);
+};
+export const renameIndexeddbRequestVariablesTransform = {
+    id: "rename-indexeddb-request-variables",
+    description: "Renames IndexedDB open/deleteDatabase request bindings to stable dbRequest names based on request event usage",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const fileInfo of getFilesToProcess(context)) {
+            if (hasDynamicNameLookup(fileInfo.ast))
+                continue;
+            const renameCandidatesByScope = new Map();
+            const isScript = fileInfo.ast.program.sourceType === "script";
+            const exportedNames = collectExportedNames(fileInfo.ast.program);
+            traverse(fileInfo.ast, {
+                VariableDeclarator(path) {
+                    nodesVisited++;
+                    const id = path.node.id;
+                    if (id.type !== "Identifier")
+                        return;
+                    if (isStableRenamed(id.name))
+                        return;
+                    if (id.name.toLowerCase().includes("request"))
+                        return;
+                    const initMethod = getRequestMethod(path.node.init);
+                    if (!initMethod)
+                        return;
+                    const binding = path.scope.getBinding(id.name);
+                    if (!binding)
+                        return;
+                    if (!binding.constant)
+                        return;
+                    if (binding.referencePaths.length === 0)
+                        return;
+                    if (isScript && binding.scope.block.type === "Program")
+                        return;
+                    if (binding.scope.block.type === "Program" &&
+                        exportedNames.has(id.name)) {
+                        return;
+                    }
+                    const usage = getIndexedDBRequestUsage(binding);
+                    if (!usage)
+                        return;
+                    if (usage.properties.size < 2)
+                        return;
+                    if (initMethod === "open" &&
+                        !hasOpenRequestSpecificSignals(usage.properties)) {
+                        return;
+                    }
+                    const existing = renameCandidatesByScope.get(binding.scope);
+                    if (existing) {
+                        existing.push(binding);
+                    }
+                    else {
+                        renameCandidatesByScope.set(binding.scope, [binding]);
+                    }
+                },
+            });
+            for (const [scope, bindings] of renameCandidatesByScope) {
+                bindings.sort((a, b) => {
+                    const aStart = getBindingStableStart(a);
+                    const bStart = getBindingStableStart(b);
+                    if (aStart !== bStart)
+                        return aStart - bStart;
+                    return a.identifier.name.localeCompare(b.identifier.name);
+                });
+                for (const binding of bindings) {
+                    // Apply per binding to force stable `$dbRequest` slots (`$dbRequest`,
+                    // `$dbRequest2`, ...) even when multiple request bindings share scope.
+                    const group = new RenameGroup();
+                    group.add({
+                        scope,
+                        currentName: binding.identifier.name,
+                        baseName: BASE_NAME,
+                    });
+                    transformationsApplied += group.apply();
+                }
+            }
+        }
+        return Promise.resolve({ nodesVisited, transformationsApplied });
+    },
+};

package/dist/transforms/rename-invalid-parameter-arguments/manifest.json

@@ -0,0 +1,13 @@
+{
+    "recommended": true,
+    "notes": "Added to recommended for readability of invalidParameterError call sites.",
+    "evaluations": {
+        "claude-code-2.1.10:claude-code-2.1.11": {
+            "diffSizePercent": 99.99811516350957,
+            "evaluatedAt": "2026-02-06T12:52:02.935Z",
+            "changedLines": 452,
+            "durationSeconds": 211.048545671,
+            "stableNames": 1381
+        }
+    }
+}

package/dist/transforms/rename-invalid-parameter-arguments/rename-invalid-parameter-arguments-transform.d.ts

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

package/dist/transforms/rename-invalid-parameter-arguments/rename-invalid-parameter-arguments-transform.js

@@ -0,0 +1,142 @@
+import { createRequire } from "node:module";
+import { isIdentifierName, isKeyword, isStrictBindReservedWord, } from "@babel/helper-validator-identifier";
+import { RenameGroup, canUseExactStableName, isStableRenamed, } from "../../core/stable-naming.js";
+import { getFilesToProcess, } from "../../core/types.js";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const traverse = require("@babel/traverse").default;
+const getValidBaseName = (value) => {
+    const trimmed = value.trim();
+    if (trimmed.length === 0)
+        return undefined;
+    const normalized = trimmed.replace(/^\$+/u, "");
+    if (normalized.length === 0)
+        return undefined;
+    if (!isIdentifierName(normalized))
+        return undefined;
+    if (normalized.startsWith("h_"))
+        return undefined;
+    if (normalized.startsWith("f_"))
+        return undefined;
+    if (normalized.startsWith("v_"))
+        return undefined;
+    // Keep module-mode strictness to avoid introducing bindings that become
+    // invalid when sourceType resolves to module in unambiguous parsing.
+    if (isKeyword(normalized) || isStrictBindReservedWord(normalized, true)) {
+        return undefined;
+    }
+    return normalized;
+};
+const isInvalidParameterErrorCallee = (callee) => {
+    if (callee.type === "Identifier") {
+        return callee.name === "invalidParameterError";
+    }
+    if (callee.type !== "MemberExpression")
+        return false;
+    if (callee.object.type !== "Identifier")
+        return false;
+    if (callee.object.name !== "errors")
+        return false;
+    if (callee.computed)
+        return false;
+    if (callee.property.type !== "Identifier")
+        return false;
+    return callee.property.name === "invalidParameterError";
+};
+const getInvalidParameterRename = (path) => {
+    if (!isInvalidParameterErrorCallee(path.node.callee))
+        return undefined;
+    if (path.node.arguments.length !== 3)
+        return undefined;
+    const [nameArgument, expectedTypeArgument, valueArgument] = path.node.arguments;
+    if (nameArgument?.type !== "StringLiteral")
+        return undefined;
+    // Keep this intentionally strict: we only rename for the canonical
+    // invalidParameterError("name", "expected", actual) signature.
+    if (expectedTypeArgument?.type !== "StringLiteral")
+        return undefined;
+    if (valueArgument?.type !== "Identifier")
+        return undefined;
+    const baseName = getValidBaseName(nameArgument.value);
+    if (!baseName)
+        return undefined;
+    const binding = path.scope.getBinding(valueArgument.name);
+    if (!binding)
+        return undefined;
+    if (binding.kind !== "param")
+        return undefined;
+    if (isStableRenamed(binding.identifier.name))
+        return undefined;
+    // Preserve already-semantic parameter names instead of forcing `$name`.
+    if (binding.identifier.name === baseName)
+        return undefined;
+    return {
+        baseName,
+        binding,
+        scope: binding.scope,
+    };
+};
+export const renameInvalidParameterArgumentsTransform = {
+    id: "rename-invalid-parameter-arguments",
+    description: 'Renames minified parameters passed to invalidParameterError("name", ...) to matching names, preferring stable $name when unambiguous and available.',
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const fileInfo of getFilesToProcess(context)) {
+            const group = new RenameGroup();
+            const candidateByBinding = new Map();
+            const conflictedBindings = new Set();
+            traverse(fileInfo.ast, {
+                CallExpression(path) {
+                    nodesVisited++;
+                    const candidate = getInvalidParameterRename(path);
+                    if (!candidate)
+                        return;
+                    if (conflictedBindings.has(candidate.binding))
+                        return;
+                    const existing = candidateByBinding.get(candidate.binding);
+                    if (!existing) {
+                        candidateByBinding.set(candidate.binding, candidate);
+                        return;
+                    }
+                    if (existing.baseName === candidate.baseName)
+                        return;
+                    candidateByBinding.delete(candidate.binding);
+                    conflictedBindings.add(candidate.binding);
+                },
+            });
+            const baseNameCountsByScope = new Map();
+            for (const candidate of candidateByBinding.values()) {
+                let countByBaseName = baseNameCountsByScope.get(candidate.scope);
+                if (!countByBaseName) {
+                    countByBaseName = new Map();
+                    baseNameCountsByScope.set(candidate.scope, countByBaseName);
+                }
+                countByBaseName.set(candidate.baseName, (countByBaseName.get(candidate.baseName) ?? 0) + 1);
+            }
+            for (const candidate of candidateByBinding.values()) {
+                const countByBaseName = baseNameCountsByScope.get(candidate.scope);
+                if (!countByBaseName)
+                    continue;
+                const baseNameCount = countByBaseName.get(candidate.baseName);
+                if (!baseNameCount || baseNameCount > 1)
+                    continue;
+                if (!canUseExactStableName(candidate.scope, candidate.binding, candidate.binding.identifier.name, candidate.baseName)) {
+                    continue;
+                }
+                group.add({
+                    scope: candidate.scope,
+                    currentName: candidate.binding.identifier.name,
+                    baseName: candidate.baseName,
+                });
+            }
+            transformationsApplied += group.apply();
+        }
+        return Promise.resolve({
+            nodesVisited,
+            transformationsApplied,
+        });
+    },
+};

package/package.json

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