miniread 1.75.0 → 1.76.0

package/dist/transforms/_generated/manifest.js

@@ -124,9 +124,14 @@ const manifestData = {
     },
     "rename-error-first-callback-parameters": {
         recommended: true,
-        notes: "Measured with baseline none: 0.00%.",
+        notes: "Measured with baseline none: diff size remains 100.00% of baseline for this evaluation set. This transform remains recommended because it targets no-else error-first guards and is complementary to rename-error-first-callback-parameters-v2.",
         evaluations: { "legacy:evaluation": { "evaluatedAt": "2026-01-25T21:27:50.901Z", "changedLines": 448, "durationSeconds": 0, "stableNames": 0, "diffSizePercent": 100 }, "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 100, "evaluatedAt": "2026-01-27T06:34:23.332Z", "changedLines": 440, "durationSeconds": 50.931335125000004, "stableNames": 1360 } },
     },
+    "rename-error-first-callback-parameters-v2": {
+        recommended: true,
+        notes: "Complementary to rename-error-first-callback-parameters. V2 covers reject/resolve guard shapes; v1 covers no-else callback guards, so both remain recommended.",
+        evaluations: { "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 99.99623032701913, "evaluatedAt": "2026-02-05T18:52:37.018Z", "changedLines": 172, "durationSeconds": 177.047075468, "stableNames": 1357 } },
+    },
     "rename-error-variables": {
         recommended: true,
         notes: "Auto-added by evaluation script.",
@@ -443,6 +448,7 @@ export const recommendedTransformIds = [
     "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",

package/dist/transforms/_generated/registry.js

@@ -25,6 +25,7 @@ import { renameDeferredResolveParametersTransform } from "../rename-deferred-res
 import { renameDestructuredAliasesTransform } from "../rename-destructured-aliases/rename-destructured-aliases-transform.js";
 import { renameDocumentFragmentVariablesTransform } from "../rename-document-fragment-variables/rename-document-fragment-variables-transform.js";
 import { renameErrorFirstCallbackParametersTransform } from "../rename-error-first-callback-parameters/rename-error-first-callback-parameters-transform.js";
+import { renameErrorFirstCallbackParametersV2Transform } from "../rename-error-first-callback-parameters-v2/rename-error-first-callback-parameters-v2-transform.js";
 import { renameErrorVariablesTransform } from "../rename-error-variables/rename-error-variables-transform.js";
 import { renameEventParametersTransform } from "../rename-event-parameters/rename-event-parameters-transform.js";
 import { renameExecfileArgumentsTransform } from "../rename-execfile-arguments/rename-execfile-arguments-transform.js";
@@ -107,6 +108,7 @@ export const transformRegistry = {
     [renameDestructuredAliasesTransform.id]: renameDestructuredAliasesTransform,
     [renameDocumentFragmentVariablesTransform.id]: renameDocumentFragmentVariablesTransform,
     [renameErrorFirstCallbackParametersTransform.id]: renameErrorFirstCallbackParametersTransform,
+    [renameErrorFirstCallbackParametersV2Transform.id]: renameErrorFirstCallbackParametersV2Transform,
     [renameErrorVariablesTransform.id]: renameErrorVariablesTransform,
     [renameEventParametersTransform.id]: renameEventParametersTransform,
     [renameExecfileArgumentsTransform.id]: renameExecfileArgumentsTransform,

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-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-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"];

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

@@ -44,6 +44,7 @@ export const recommendedTransformOrder = [
     "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",

package/dist/transforms/rename-error-first-callback-parameters/manifest.json

@@ -16,5 +16,5 @@
             "stableNames": 1360
         }
     },
-    "notes": "Measured with baseline none: 0.00%."
+    "notes": "Measured with baseline none: diff size remains 100.00% of baseline for this evaluation set. This transform remains recommended because it targets no-else error-first guards and is complementary to rename-error-first-callback-parameters-v2."
 }

package/dist/transforms/rename-error-first-callback-parameters-v2/get-leading-error-first-guard.d.ts

@@ -0,0 +1,8 @@
+import type { NodePath } from "@babel/traverse";
+import type { Function, IfStatement, Node } from "@babel/types";
+type LeadingErrorFirstGuard = {
+    ifStatement: IfStatement;
+    resultBranch: Node;
+};
+export declare const getLeadingErrorFirstGuard: (path: NodePath<Function>) => LeadingErrorFirstGuard | undefined;
+export {};

package/dist/transforms/rename-error-first-callback-parameters-v2/get-leading-error-first-guard.js

@@ -0,0 +1,33 @@
+const isDirectiveStatement = (node) => node?.type === "ExpressionStatement" &&
+    node.expression.type === "StringLiteral";
+export const getLeadingErrorFirstGuard = (path) => {
+    const body = path.node.body;
+    if (body.type !== "BlockStatement")
+        return undefined;
+    let firstMeaningfulStatementIndex = 0;
+    while (firstMeaningfulStatementIndex < body.body.length) {
+        const statement = body.body[firstMeaningfulStatementIndex];
+        if (!isDirectiveStatement(statement))
+            break;
+        firstMeaningfulStatementIndex++;
+    }
+    const firstStatement = body.body[firstMeaningfulStatementIndex];
+    if (firstStatement?.type !== "IfStatement")
+        return undefined;
+    if (firstStatement.alternate) {
+        return {
+            ifStatement: firstStatement,
+            resultBranch: firstStatement.alternate,
+        };
+    }
+    const nextStatement = body.body[firstMeaningfulStatementIndex + 1];
+    if (!nextStatement)
+        return undefined;
+    // Guard-clause shape intentionally targets:
+    // if (err) return reject(err); <single resolve-call statement>
+    // and does not attempt to match multi-statement success paths.
+    return {
+        ifStatement: firstStatement,
+        resultBranch: nextStatement,
+    };
+};

package/dist/transforms/rename-error-first-callback-parameters-v2/has-named-direct-branch-call-argument-reference.d.ts

@@ -0,0 +1,3 @@
+import type { NodePath } from "@babel/traverse";
+import type { Node } from "@babel/types";
+export declare const hasNamedDirectBranchCallArgumentReference: (bindingReferences: Array<NodePath>, node: Node, namePrefix: string, isReferenceInsideNode: (referencePath: NodePath, node: Node) => boolean) => boolean;

package/dist/transforms/rename-error-first-callback-parameters-v2/has-named-direct-branch-call-argument-reference.js

@@ -0,0 +1,44 @@
+const toDirectCallExpression = (node) => {
+    if (node.type === "ExpressionStatement") {
+        return node.expression.type === "CallExpression"
+            ? node.expression
+            : undefined;
+    }
+    if (node.type === "ReturnStatement") {
+        return node.argument?.type === "CallExpression" ? node.argument : undefined;
+    }
+    return undefined;
+};
+const getDirectBranchCallExpressions = (node) => {
+    if (node.type !== "BlockStatement") {
+        const callExpression = toDirectCallExpression(node);
+        return callExpression ? [callExpression] : [];
+    }
+    const callExpressions = [];
+    for (const statement of node.body) {
+        const callExpression = toDirectCallExpression(statement);
+        if (callExpression)
+            callExpressions.push(callExpression);
+    }
+    return callExpressions;
+};
+const callExpressionNameStartsWith = (callExpression, namePrefix) => {
+    const callee = callExpression.callee;
+    if (callee.type !== "Identifier")
+        return false;
+    const normalizedName = callee.name.startsWith("$")
+        ? callee.name.slice(1)
+        : callee.name;
+    return normalizedName.startsWith(namePrefix);
+};
+const isReferenceInsideCallArguments = (referencePath, callExpression, isReferenceInsideNode) => callExpression.arguments.some((argumentNode) => isReferenceInsideNode(referencePath, argumentNode));
+export const hasNamedDirectBranchCallArgumentReference = (bindingReferences, node, namePrefix, isReferenceInsideNode) => {
+    const directCallExpressions = getDirectBranchCallExpressions(node);
+    if (directCallExpressions.length === 0)
+        return false;
+    return directCallExpressions.some((callExpression) => {
+        if (!callExpressionNameStartsWith(callExpression, namePrefix))
+            return false;
+        return bindingReferences.some((referencePath) => isReferenceInsideCallArguments(referencePath, callExpression, isReferenceInsideNode));
+    });
+};

package/dist/transforms/rename-error-first-callback-parameters-v2/manifest.json

@@ -0,0 +1,13 @@
+{
+    "recommended": true,
+    "evaluations": {
+        "claude-code-2.1.10:claude-code-2.1.11": {
+            "diffSizePercent": 99.99623032701913,
+            "evaluatedAt": "2026-02-05T18:52:37.018Z",
+            "changedLines": 172,
+            "durationSeconds": 177.047075468,
+            "stableNames": 1357
+        }
+    },
+    "notes": "Complementary to rename-error-first-callback-parameters. V2 covers reject/resolve guard shapes; v1 covers no-else callback guards, so both remain recommended."
+}

package/dist/transforms/rename-error-first-callback-parameters-v2/match-error-first-reject-resolve-pattern.d.ts

@@ -0,0 +1,6 @@
+import type { NodePath } from "@babel/traverse";
+import type { Function } from "@babel/types";
+export declare const matchErrorFirstRejectResolvePattern: (path: NodePath<Function>) => {
+    errorName: string;
+    resultName: string;
+} | undefined;

package/dist/transforms/rename-error-first-callback-parameters-v2/match-error-first-reject-resolve-pattern.js

@@ -0,0 +1,66 @@
+import { getLeadingErrorFirstGuard } from "./get-leading-error-first-guard.js";
+import { hasNamedDirectBranchCallArgumentReference } from "./has-named-direct-branch-call-argument-reference.js";
+const REJECT_NAME_PREFIX = "reject";
+const RESOLVE_NAME_PREFIX = "resolve";
+const isReferenceInsideNode = (referencePath, node) => {
+    if (referencePath.node === node)
+        return true;
+    return Boolean(referencePath.findParent((parent) => parent.node === node));
+};
+const allReferencesInsideNodes = (bindingReferences, nodes) => bindingReferences.every((referencePath) => nodes.some((node) => isReferenceInsideNode(referencePath, node)));
+const hasReferenceInsideNode = (bindingReferences, node) => bindingReferences.some((referencePath) => isReferenceInsideNode(referencePath, node));
+export const matchErrorFirstRejectResolvePattern = (path) => {
+    const [errorParameter, resultParameter] = path.node.params;
+    if (errorParameter?.type !== "Identifier")
+        return undefined;
+    if (resultParameter?.type !== "Identifier")
+        return undefined;
+    if (errorParameter.name === resultParameter.name)
+        return undefined;
+    const errorBinding = path.scope.getBinding(errorParameter.name);
+    if (!errorBinding)
+        return undefined;
+    if (errorBinding.kind !== "param")
+        return undefined;
+    if (errorBinding.referencePaths.length === 0)
+        return undefined;
+    const resultBinding = path.scope.getBinding(resultParameter.name);
+    if (!resultBinding)
+        return undefined;
+    if (resultBinding.kind !== "param")
+        return undefined;
+    if (resultBinding.referencePaths.length === 0)
+        return undefined;
+    const guard = getLeadingErrorFirstGuard(path);
+    if (!guard)
+        return undefined;
+    const { ifStatement, resultBranch } = guard;
+    if (ifStatement.test.type !== "Identifier")
+        return undefined;
+    if (ifStatement.test.name !== errorParameter.name)
+        return undefined;
+    const errorReferences = errorBinding.referencePaths;
+    const resultReferences = resultBinding.referencePaths;
+    if (!allReferencesInsideNodes(errorReferences, [
+        ifStatement.test,
+        ifStatement.consequent,
+    ])) {
+        return undefined;
+    }
+    if (!hasReferenceInsideNode(errorReferences, ifStatement.consequent))
+        return undefined;
+    if (!hasNamedDirectBranchCallArgumentReference(errorReferences, ifStatement.consequent, REJECT_NAME_PREFIX, isReferenceInsideNode)) {
+        return undefined;
+    }
+    if (!allReferencesInsideNodes(resultReferences, [resultBranch]))
+        return undefined;
+    if (!hasReferenceInsideNode(resultReferences, resultBranch))
+        return undefined;
+    if (!hasNamedDirectBranchCallArgumentReference(resultReferences, resultBranch, RESOLVE_NAME_PREFIX, isReferenceInsideNode)) {
+        return undefined;
+    }
+    return {
+        errorName: errorParameter.name,
+        resultName: resultParameter.name,
+    };
+};

package/dist/transforms/rename-error-first-callback-parameters-v2/rename-error-first-callback-parameters-v2-transform.d.ts

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

package/dist/transforms/rename-error-first-callback-parameters-v2/rename-error-first-callback-parameters-v2-transform.js

@@ -0,0 +1,46 @@
+import { createRequire } from "node:module";
+import { RenameGroup } from "../../core/stable-naming.js";
+import { getFilesToProcess, } from "../../core/types.js";
+import { matchErrorFirstRejectResolvePattern } from "./match-error-first-reject-resolve-pattern.js";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const traverse = require("@babel/traverse").default;
+const ERROR_BASE_NAME = "error";
+const RESULT_BASE_NAME = "result";
+export const renameErrorFirstCallbackParametersV2Transform = {
+    id: "rename-error-first-callback-parameters-v2",
+    description: "Renames error-first callback parameters in leading reject/resolve guards to error/result names (stable $error/$result when possible).",
+    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 = matchErrorFirstRejectResolvePattern(path);
+                    if (!match)
+                        return;
+                    const { errorName, resultName } = match;
+                    group.add({
+                        scope: path.scope,
+                        currentName: errorName,
+                        baseName: ERROR_BASE_NAME,
+                    });
+                    group.add({
+                        scope: path.scope,
+                        currentName: resultName,
+                        baseName: RESULT_BASE_NAME,
+                    });
+                },
+            });
+            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.75.0",
+  "version": "1.76.0",
   "description": "Transform minified JavaScript/TypeScript into a more readable form using deterministic AST-based transforms.",
   "repository": {
     "type": "git",