miniread 1.82.0 → 1.84.0

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

@@ -41,6 +41,10 @@ type RenameEntry = {
     /** Desired semantic base name (e.g., "timeoutId", "error") */
     baseName: string;
 };
+export declare const findAvailableStableRenameName: (scope: Scope, binding: Binding | undefined, baseName: string, startIndex: number, currentName: string) => {
+    name: string;
+    nextIndex: number;
+};
 /**
  * Collects rename operations and applies them with automatic stability logic.
  *

package/dist/core/stable-naming.js

@@ -154,6 +154,7 @@ const findAvailableName = (scope, binding, baseName, startIndex, canBeStable, cu
         return { name: candidateReadable, nextIndex: index + 1 };
     }
 };
+export const findAvailableStableRenameName = (scope, binding, baseName, startIndex, currentName) => findAvailableName(scope, binding, baseName, startIndex, true, currentName);
 /**
  * Collects rename operations and applies them with automatic stability logic.
  *

package/dist/transforms/_generated/manifest.js

@@ -38,6 +38,10 @@ const manifestData = {
         notes: "Added manually; improves readability by reducing nesting.",
         evaluations: { "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 100, "evaluatedAt": "2026-01-25T23:01:41.815Z", "changedLines": 5208, "durationSeconds": 58.302647375, "stableNames": 1357 } },
     },
+    "rename-add-event-listener-parameters": {
+        recommended: true,
+        evaluations: { "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 100, "evaluatedAt": "2026-02-06T17:38:36.844Z", "changedLines": 8, "durationSeconds": 179.627881234, "stableNames": 1359 } },
+    },
     "rename-arguments-length-flags": {
         recommended: true,
         notes: "Measured with baseline none: 0.00%. Added to recommended for readability.",
@@ -232,6 +236,10 @@ const manifestData = {
         notes: "Extends v1 to also handle this.property = param assignments.",
         evaluations: { "legacy:evaluation": { "evaluatedAt": "2026-01-25T20:07:10.063Z", "changedLines": 20493, "durationSeconds": 0, "stableNames": 0, "diffSizePercent": 99.99244056393393 }, "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 99.99244056393393, "evaluatedAt": "2026-01-25T23:24:32.608Z", "changedLines": 20493, "durationSeconds": 56.743425875, "stableNames": 1357 } },
     },
+    "rename-platform-win32-flags": {
+        recommended: true,
+        evaluations: { "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 99.99623032701913, "evaluatedAt": "2026-02-06T14:58:00.533Z", "changedLines": 42, "durationSeconds": 224.696743585, "stableNames": 1358 } },
+    },
     "rename-process-stdout-handlers": {
         recommended: false,
         notes: "Measured with baseline none: -0.0019%. Kept out of recommended due to slight negative diff impact, but useful for readability in stdout hook handlers.",
@@ -462,6 +470,7 @@ export const recommendedTransformIds = [
     "rename-charcode-variables-v2",
     "rename-client-aliases",
     "rename-comparison-flags",
+    "rename-platform-win32-flags",
     "rename-date-now-start-times",
     "rename-default-options-parameters-v2",
     "rename-deferred-resolve-parameters",
@@ -475,6 +484,7 @@ export const recommendedTransformIds = [
     "rename-error-first-callback-parameters-v2",
     "rename-error-variables",
     "rename-event-parameters",
+    "rename-add-event-listener-parameters",
     "rename-http-server-parameters",
     "rename-fs-sync-variables",
     "rename-http-method-parameters",

package/dist/transforms/_generated/registry.js

@@ -7,6 +7,7 @@ import { expandSpecialNumberLiteralsTransform } from "../expand-special-number-l
 import { expandTypeofUndefinedComparisonsTransform } from "../expand-typeof-undefined-comparisons/expand-typeof-undefined-comparisons-transform.js";
 import { expandUndefinedLiteralsTransform } from "../expand-undefined-literals/expand-undefined-literals-transform.js";
 import { removeRedundantElseTransform } from "../remove-redundant-else/remove-redundant-else-transform.js";
+import { renameAddEventListenerParametersTransform } from "../rename-add-event-listener-parameters/rename-add-event-listener-parameters-transform.js";
 import { renameArgumentsLengthFlagsTransform } from "../rename-arguments-length-flags/rename-arguments-length-flags-transform.js";
 import { renameAsapWrappersTransform } from "../rename-asap-wrappers/rename-asap-wrappers-transform.js";
 import { renameAwaiterHelperFunctionsTransform } from "../rename-awaiter-helper-functions/rename-awaiter-helper-functions-transform.js";
@@ -47,6 +48,7 @@ import { renameObjectKeysReducerParametersTransform } from "../rename-object-key
 import { renameObjectKeysVariablesTransform } from "../rename-object-keys-variables/rename-object-keys-variables-transform.js";
 import { renameParametersToMatchPropertiesTransform } from "../rename-parameters-to-match-properties/rename-parameters-to-match-properties-transform.js";
 import { renameParametersToMatchPropertiesV2Transform } from "../rename-parameters-to-match-properties-v2/rename-parameters-to-match-properties-v2-transform.js";
+import { renamePlatformWin32FlagsTransform } from "../rename-platform-win32-flags/rename-platform-win32-flags-transform.js";
 import { renameProcessStdoutHandlersTransform } from "../rename-process-stdout-handlers/rename-process-stdout-handlers-transform.js";
 import { renamePromiseCatchParametersTransform } from "../rename-promise-catch-parameters/rename-promise-catch-parameters-transform.js";
 import { renamePromiseExecutorParametersTransform } from "../rename-promise-executor-parameters/rename-promise-executor-parameters-transform.js";
@@ -95,6 +97,7 @@ export const transformRegistry = {
     [expandTypeofUndefinedComparisonsTransform.id]: expandTypeofUndefinedComparisonsTransform,
     [expandUndefinedLiteralsTransform.id]: expandUndefinedLiteralsTransform,
     [removeRedundantElseTransform.id]: removeRedundantElseTransform,
+    [renameAddEventListenerParametersTransform.id]: renameAddEventListenerParametersTransform,
     [renameArgumentsLengthFlagsTransform.id]: renameArgumentsLengthFlagsTransform,
     [renameAsapWrappersTransform.id]: renameAsapWrappersTransform,
     [renameAwaiterHelperFunctionsTransform.id]: renameAwaiterHelperFunctionsTransform,
@@ -135,6 +138,7 @@ export const transformRegistry = {
     [renameObjectKeysVariablesTransform.id]: renameObjectKeysVariablesTransform,
     [renameParametersToMatchPropertiesTransform.id]: renameParametersToMatchPropertiesTransform,
     [renameParametersToMatchPropertiesV2Transform.id]: renameParametersToMatchPropertiesV2Transform,
+    [renamePlatformWin32FlagsTransform.id]: renamePlatformWin32FlagsTransform,
     [renameProcessStdoutHandlersTransform.id]: renameProcessStdoutHandlersTransform,
     [renamePromiseCatchParametersTransform.id]: renamePromiseCatchParametersTransform,
     [renamePromiseExecutorParametersTransform.id]: renamePromiseExecutorParametersTransform,

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-deferred-resolve-parameters-v2", "rename-destructured-aliases", "rename-rest-parameters", "rename-rest-pop-callbacks", "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-object-keys-reducer-parameters", "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"];
+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-platform-win32-flags", "rename-date-now-start-times", "rename-default-options-parameters-v2", "rename-deferred-resolve-parameters", "rename-deferred-resolve-parameters-v2", "rename-destructured-aliases", "rename-rest-parameters", "rename-rest-pop-callbacks", "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-add-event-listener-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-object-keys-reducer-parameters", "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

@@ -36,6 +36,7 @@ export const recommendedTransformOrder = [
     "rename-charcode-variables-v2",
     "rename-client-aliases",
     "rename-comparison-flags",
+    "rename-platform-win32-flags",
     "rename-date-now-start-times",
     "rename-default-options-parameters-v2",
     "rename-deferred-resolve-parameters",
@@ -49,6 +50,7 @@ export const recommendedTransformOrder = [
     "rename-error-first-callback-parameters-v2",
     "rename-error-variables",
     "rename-event-parameters",
+    "rename-add-event-listener-parameters",
     "rename-http-server-parameters",
     // Runs after stabilize-top-level-bindings: in the recommended preset, top-level `fs` bindings
     // are already stable-hashed. This transform gives remaining non-stable `fs` helpers stable

package/dist/transforms/rename-add-event-listener-parameters/has-event-handler-usage.d.ts

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

package/dist/transforms/rename-add-event-listener-parameters/has-event-handler-usage.js

@@ -0,0 +1,42 @@
+const isHandleEventAccess = (node) => {
+    if (!node.computed && node.property.type === "Identifier") {
+        return node.property.name === "handleEvent";
+    }
+    if (node.computed && node.property.type === "StringLiteral") {
+        return node.property.value === "handleEvent";
+    }
+    return false;
+};
+const isWriteSideHandleEventAccess = (memberPath) => {
+    const parent = memberPath.parentPath;
+    if (parent.isAssignmentExpression()) {
+        return parent.node.left === memberPath.node;
+    }
+    if (parent.isUpdateExpression()) {
+        return parent.node.argument === memberPath.node;
+    }
+    return false;
+};
+export const hasEventHandlerUsage = (binding) => {
+    return binding.referencePaths.some((referencePath) => {
+        const parent = referencePath.parentPath;
+        if (!parent)
+            return false;
+        if ((parent.isCallExpression() || parent.isOptionalCallExpression()) &&
+            referencePath.key === "callee")
+            return true;
+        if ((parent.isMemberExpression() || parent.isOptionalMemberExpression()) &&
+            referencePath.key === "object") {
+            if (isWriteSideHandleEventAccess(parent))
+                return false;
+            const property = parent.node.property;
+            if (property.type !== "Identifier" && property.type !== "StringLiteral")
+                return false;
+            return isHandleEventAccess({
+                property,
+                computed: parent.node.computed,
+            });
+        }
+        return false;
+    });
+};

package/dist/transforms/rename-add-event-listener-parameters/has-event-name-comparison.d.ts

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

package/dist/transforms/rename-add-event-listener-parameters/has-event-name-comparison.js

@@ -0,0 +1,21 @@
+export const hasEventNameComparison = (binding) => {
+    return binding.referencePaths.some((referencePath) => {
+        const parent = referencePath.parentPath;
+        if (!parent)
+            return false;
+        if (parent.isBinaryExpression()) {
+            const { left, right, operator } = parent.node;
+            if (operator !== "===" && operator !== "==")
+                return false;
+            if (left === referencePath.node)
+                return right.type === "StringLiteral";
+            if (right === referencePath.node)
+                return left.type === "StringLiteral";
+            return false;
+        }
+        if (parent.isSwitchStatement() && referencePath.key === "discriminant") {
+            return parent.node.cases.some((caseClause) => caseClause.test?.type === "StringLiteral");
+        }
+        return false;
+    });
+};

package/dist/transforms/rename-add-event-listener-parameters/is-add-event-listener-key.d.ts

@@ -0,0 +1,3 @@
+import type { NodePath } from "@babel/traverse";
+import type { ObjectMethod, ObjectProperty } from "@babel/types";
+export declare const isAddEventListenerKey: (path: NodePath<ObjectMethod | ObjectProperty>) => boolean;

package/dist/transforms/rename-add-event-listener-parameters/is-add-event-listener-key.js

@@ -0,0 +1,8 @@
+export const isAddEventListenerKey = (path) => {
+    const { key, computed } = path.node;
+    if (key.type === "Identifier")
+        return !computed && key.name === "addEventListener";
+    if (key.type === "StringLiteral")
+        return key.value === "addEventListener";
+    return false;
+};

package/dist/transforms/rename-add-event-listener-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-06T17:38:36.844Z",
+            "changedLines": 8,
+            "durationSeconds": 179.627881234,
+            "stableNames": 1359
+        }
+    }
+}

package/dist/transforms/rename-add-event-listener-parameters/rename-add-event-listener-parameters-transform.d.ts

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

package/dist/transforms/rename-add-event-listener-parameters/rename-add-event-listener-parameters-transform.js

@@ -0,0 +1,91 @@
+import { createRequire } from "node:module";
+import { RenameGroup, isStableRenamed } from "../../core/stable-naming.js";
+import { getFilesToProcess, } from "../../core/types.js";
+import { hasEventHandlerUsage } from "./has-event-handler-usage.js";
+import { hasEventNameComparison } from "./has-event-name-comparison.js";
+import { isAddEventListenerKey } from "./is-add-event-listener-key.js";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const traverse = require("@babel/traverse").default;
+const EVENT_NAME_BASE = "eventName";
+const EVENT_HANDLER_BASE = "eventHandler";
+const collectAddEventListenerRename = (path, group) => {
+    if (path.node.params.length !== 2)
+        return;
+    const [eventNameParameter, handlerParameter] = path.node.params;
+    if (eventNameParameter?.type !== "Identifier")
+        return;
+    if (handlerParameter?.type !== "Identifier")
+        return;
+    const eventName = eventNameParameter.name;
+    const handlerName = handlerParameter.name;
+    if (eventName === handlerName)
+        return;
+    const shouldRenameEventName = !isStableRenamed(eventName);
+    const shouldRenameHandlerName = !isStableRenamed(handlerName);
+    if (!shouldRenameEventName && !shouldRenameHandlerName)
+        return;
+    const eventBinding = path.scope.getBinding(eventName);
+    if (!eventBinding)
+        return;
+    if (!eventBinding.constant)
+        return;
+    const handlerBinding = path.scope.getBinding(handlerName);
+    if (!handlerBinding)
+        return;
+    if (!handlerBinding.constant)
+        return;
+    if (!hasEventNameComparison(eventBinding))
+        return;
+    if (!hasEventHandlerUsage(handlerBinding))
+        return;
+    if (shouldRenameEventName) {
+        group.add({
+            scope: path.scope,
+            currentName: eventName,
+            baseName: EVENT_NAME_BASE,
+        });
+    }
+    if (shouldRenameHandlerName) {
+        group.add({
+            scope: path.scope,
+            currentName: handlerName,
+            baseName: EVENT_HANDLER_BASE,
+        });
+    }
+};
+export const renameAddEventListenerParametersTransform = {
+    id: "rename-add-event-listener-parameters",
+    description: "Renames addEventListener parameters to eventName/eventHandler when usage is high-confidence",
+    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, {
+                ObjectMethod(path) {
+                    nodesVisited++;
+                    if (!isAddEventListenerKey(path))
+                        return;
+                    collectAddEventListenerRename(path, group);
+                },
+                ObjectProperty(path) {
+                    nodesVisited++;
+                    if (!isAddEventListenerKey(path))
+                        return;
+                    const valuePath = path.get("value");
+                    if (valuePath.isFunctionExpression()) {
+                        collectAddEventListenerRename(valuePath, group);
+                    }
+                    else if (valuePath.isArrowFunctionExpression()) {
+                        collectAddEventListenerRename(valuePath, group);
+                    }
+                },
+            });
+            transformationsApplied += group.apply();
+        }
+        return Promise.resolve({ nodesVisited, transformationsApplied });
+    },
+};

package/dist/transforms/rename-platform-win32-flags/apply-hash-stable-win32-renames.d.ts

@@ -0,0 +1,8 @@
+import type { Binding, Scope } from "@babel/traverse";
+export type HashRenameEntry = {
+    baseName: string;
+    binding: Binding;
+    currentName: string;
+    scope: Scope;
+};
+export declare const applyHashStableWin32Renames: (hashEntries: HashRenameEntry[]) => number;

package/dist/transforms/rename-platform-win32-flags/apply-hash-stable-win32-renames.js

@@ -0,0 +1,37 @@
+import { findAvailableStableRenameName } from "../../core/stable-naming.js";
+export const applyHashStableWin32Renames = (hashEntries) => {
+    let transformationsApplied = 0;
+    const hashScopeGroups = new Map();
+    for (const entry of hashEntries) {
+        let baseNameMap = hashScopeGroups.get(entry.scope);
+        if (!baseNameMap) {
+            baseNameMap = new Map();
+            hashScopeGroups.set(entry.scope, baseNameMap);
+        }
+        let baseGroup = baseNameMap.get(entry.baseName);
+        if (!baseGroup) {
+            baseGroup = [];
+            baseNameMap.set(entry.baseName, baseGroup);
+        }
+        baseGroup.push(entry);
+    }
+    for (const [scope, baseNameMap] of hashScopeGroups) {
+        for (const [baseName, baseGroup] of baseNameMap) {
+            const sortedGroup = baseGroup.toSorted((a, b) => a.currentName < b.currentName
+                ? -1
+                : a.currentName > b.currentName
+                    ? 1
+                    : 0);
+            let index = 1;
+            for (const entry of sortedGroup) {
+                const target = findAvailableStableRenameName(scope, entry.binding, baseName, index, entry.currentName);
+                index = target.nextIndex;
+                if (target.name === entry.currentName)
+                    continue;
+                scope.rename(entry.currentName, target.name);
+                transformationsApplied++;
+            }
+        }
+    }
+    return transformationsApplied;
+};

package/dist/transforms/rename-platform-win32-flags/is-safe-process-binding.d.ts

@@ -0,0 +1,3 @@
+import type { NodePath } from "@babel/traverse";
+import type { VariableDeclarator } from "@babel/types";
+export declare const isSafeProcessBinding: (path: NodePath<VariableDeclarator>, identifierName: string) => boolean;

package/dist/transforms/rename-platform-win32-flags/is-safe-process-binding.js

@@ -0,0 +1,48 @@
+import { isNodeRequireInScope } from "../is-require-from-url-module.js";
+const isProcessSpecifier = (value) => value === "process" ||
+    value === "node:process" ||
+    value === "process/browser" ||
+    value === "node:process/browser";
+export const isSafeProcessBinding = (path, identifierName) => {
+    const processBinding = path.scope.getBinding(identifierName);
+    if (!processBinding)
+        return identifierName === "process";
+    const bindingPath = processBinding.path;
+    if (bindingPath.isImportDefaultSpecifier() ||
+        bindingPath.isImportNamespaceSpecifier() ||
+        bindingPath.isImportSpecifier()) {
+        const parent = bindingPath.parent;
+        if (parent.type !== "ImportDeclaration")
+            return false;
+        if (!isProcessSpecifier(parent.source.value))
+            return false;
+        if (bindingPath.isImportSpecifier()) {
+            const imported = bindingPath.node.imported;
+            if (imported.type !== "Identifier")
+                return false;
+            return imported.name === "default";
+        }
+        return true;
+    }
+    if (!bindingPath.isVariableDeclarator())
+        return false;
+    const init = bindingPath.node.init;
+    if (!init)
+        return false;
+    if (init.type !== "CallExpression")
+        return false;
+    if (init.callee.type !== "Identifier")
+        return false;
+    if (init.callee.name !== "require")
+        return false;
+    if (!isNodeRequireInScope(bindingPath.scope))
+        return false;
+    if (init.arguments.length !== 1)
+        return false;
+    const argument0 = init.arguments[0];
+    if (!argument0)
+        return false;
+    if (argument0.type !== "StringLiteral")
+        return false;
+    return isProcessSpecifier(argument0.value);
+};

package/dist/transforms/rename-platform-win32-flags/manifest.json

@@ -0,0 +1,12 @@
+{
+    "recommended": true,
+    "evaluations": {
+        "claude-code-2.1.10:claude-code-2.1.11": {
+            "diffSizePercent": 99.99623032701913,
+            "evaluatedAt": "2026-02-06T14:58:00.533Z",
+            "changedLines": 42,
+            "durationSeconds": 224.696743585,
+            "stableNames": 1358
+        }
+    }
+}

package/dist/transforms/rename-platform-win32-flags/rename-platform-win32-flags-transform.d.ts

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

package/dist/transforms/rename-platform-win32-flags/rename-platform-win32-flags-transform.js

@@ -0,0 +1,112 @@
+import { createRequire } from "node:module";
+import { collectExportedNames } from "../../core/collect-exported-names.js";
+import { isHashBasedStableName, RenameGroup, } from "../../core/stable-naming.js";
+import { getFilesToProcess, } from "../../core/types.js";
+import { applyHashStableWin32Renames, } from "./apply-hash-stable-win32-renames.js";
+import { isSafeProcessBinding } from "./is-safe-process-binding.js";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const traverse = require("@babel/traverse").default;
+const WIN32_LITERAL = "win32";
+const isProcessPlatformExpression = (node) => {
+    if (node.type !== "MemberExpression")
+        return false;
+    if (node.computed)
+        return false;
+    if (node.object.type !== "Identifier")
+        return false;
+    // We intentionally keep this structural and verify process identity separately.
+    if (node.property.type !== "Identifier")
+        return false;
+    if (node.property.name !== "platform")
+        return false;
+    return true;
+};
+const isWin32Literal = (node) => {
+    if (node.type !== "StringLiteral")
+        return false;
+    return node.value === WIN32_LITERAL;
+};
+const getWin32BaseName = (node) => {
+    if (node.operator !== "===" && node.operator !== "!==")
+        return undefined;
+    const matchesLeft = isProcessPlatformExpression(node.left) && isWin32Literal(node.right);
+    const matchesRight = isProcessPlatformExpression(node.right) && isWin32Literal(node.left);
+    if (!matchesLeft && !matchesRight)
+        return undefined;
+    return node.operator === "===" ? "isWindows" : "isNotWindows";
+};
+const getPlatformIdentifierName = (node) => {
+    if (isProcessPlatformExpression(node.left)) {
+        return node.left.object.name;
+    }
+    if (isProcessPlatformExpression(node.right)) {
+        return node.right.object.name;
+    }
+    return undefined;
+};
+export const renamePlatformWin32FlagsTransform = {
+    id: "rename-platform-win32-flags",
+    description: 'Renames process.platform ===/!== "win32" variables to readable Windows flag names',
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const fileInfo of getFilesToProcess(context)) {
+            const group = new RenameGroup();
+            const hashEntries = [];
+            const exportedNames = collectExportedNames(fileInfo.ast.program);
+            traverse(fileInfo.ast, {
+                VariableDeclarator(path) {
+                    nodesVisited++;
+                    const id = path.node.id;
+                    if (id.type !== "Identifier")
+                        return;
+                    const init = path.node.init;
+                    if (init?.type !== "BinaryExpression")
+                        return;
+                    const platformIdentifierName = getPlatformIdentifierName(init);
+                    if (!platformIdentifierName)
+                        return;
+                    if (!isSafeProcessBinding(path, platformIdentifierName))
+                        return;
+                    const baseName = getWin32BaseName(init);
+                    if (!baseName)
+                        return;
+                    const binding = path.scope.getBinding(id.name);
+                    if (!binding)
+                        return;
+                    if (!binding.constant)
+                        return;
+                    // Intentionally skip single-declaration dead flags to avoid churn;
+                    // unlike generic comparison-flags, this transform targets a narrow,
+                    // semantically named pattern where dead-code renames add little value.
+                    if (binding.referencePaths.length === 0)
+                        return;
+                    if (binding.scope.block.type === "Program" &&
+                        exportedNames.has(id.name)) {
+                        return;
+                    }
+                    if (isHashBasedStableName(id.name)) {
+                        hashEntries.push({
+                            baseName,
+                            binding,
+                            currentName: id.name,
+                            scope: path.scope,
+                        });
+                        return;
+                    }
+                    group.add({
+                        scope: path.scope,
+                        currentName: id.name,
+                        baseName,
+                    });
+                },
+            });
+            transformationsApplied += applyHashStableWin32Renames(hashEntries);
+            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.82.0",
+  "version": "1.84.0",
   "description": "Transform minified JavaScript/TypeScript into a more readable form using deterministic AST-based transforms.",
   "repository": {
     "type": "git",