miniread 1.96.1 → 1.98.0

package/README.md

@@ -17,19 +17,21 @@ miniread --list-transforms
 miniread --input ./minified --output ./readable --transforms recommended
 miniread --input ./minified --output ./readable --dry-run
 miniread --input ./minified --output ./readable --workers 8
+miniread --input ./minified --output ./readable --ignore-dirs dist,coverage
 miniread --input ./minified --output ./readable --safe-stabilize-top-level-bindings
-miniread --input ./repo --output ./readable --ignore-dirs none
 ```
 
-When scanning an input directory, miniread ignores `.git`, `node_modules`, `coverage`, `.turbo`, and `.next` by default. `--ignore-dirs` replaces that default list (for example: `--ignore-dirs build,dist`), and `--ignore-dirs none` disables ignores entirely.
+When scanning input directories, `miniread` ignores common heavy folders by
+default: `.git`, `node_modules`, `coverage`, `.next`, `.nuxt`, `dist`, `build`,
+`out`, and `.cache`.
+
+Use `--ignore-dirs <comma-separated-names>` to add more directory names to the
+ignore set (matching is case-insensitive).
 
 ## Output stability
 
 The recommended preset includes `stabilize-top-level-bindings`, which renames program-scope bindings to stable hash-based names (`$h_<hash>`). This produces deterministic output across minifier versions, making diffs more useful.
 
-The `recommended` preset prioritizes readability and may include documented heuristics where edge-case behavioral differences are possible.
-One example is `simplify-filter-boolean-coercion`, which matches `.filter(...)` heuristically; strict-boolean custom filter implementations can behave differently.
-
 By default, this transform runs even when it detects code patterns (like `eval`) that could make the output non-runnable. Use `--safe-stabilize-top-level-bindings` or set `MINIREAD_UNSAFE_STABILIZE_TOP_LEVEL_BINDINGS` to a falsy value (`0`, `false`, `no`, or empty string) to skip renaming in such cases.
 
 ## Examples
@@ -95,6 +97,22 @@ pnpm run miniread-evaluate -- --compare v1.0:v1.1 --compare v2.0:v2.1 --baseline
   | tail -n +2 | sort -k5,5nr | head -10
 ```
 
+## miniread-pick-random-transform (developer tool)
+
+The `miniread-pick-random-transform` CLI picks random transform candidates from the slowest eligible recommended transforms based on `manifest.json` evaluation metrics.
+
+### Usage
+
+```bash
+pnpm run miniread-pick-random-transform -- --help
+
+# Pick 3 random candidates from the 10 slowest eligible transforms
+pnpm run miniread-pick-random-transform
+
+# Customize evaluation key and pool size
+pnpm run miniread-pick-random-transform -- --evaluation-key v1.0:v1.1 --top 15 --pick 3
+```
+
 ## License
 
 MIT

package/bin/miniread-pick-random-transform

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+/**
+ * CLI entry point that dynamically imports the compiled TypeScript.
+ *
+ * Uses top-level await to ensure module evaluation errors are handled
+ * properly. Without await, errors during import would surface as unhandled
+ * rejections instead of clean CLI failures with appropriate exit codes.
+ */
+try {
+  await import("../dist/scripts/pick-random-transform.js");
+} catch (error) {
+  console.error(
+    "Failed to start miniread-pick-random-transform:",
+    error instanceof Error ? error.message : error,
+  );
+  process.exitCode = 1;
+}

package/dist/cli/find-input-files.d.ts

@@ -9,8 +9,7 @@ type FindInputFilesError = {
     errors: string[];
 };
 type FindInputFilesResult = FindInputFilesOk | FindInputFilesError;
-type FindInputFilesOptions = {
-    ignoredDirectories?: ReadonlySet<string>;
-};
-export declare const findInputFiles: (input: string, options?: FindInputFilesOptions) => Promise<FindInputFilesResult>;
+export declare const findInputFiles: (input: string, options?: {
+    ignoredDirectoryNames?: string[];
+}) => Promise<FindInputFilesResult>;
 export {};

package/dist/cli/find-input-files.js

@@ -7,34 +7,31 @@ const isSourceFile = (fileName) => {
             fileName.endsWith(".js") ||
             fileName.endsWith(".jsx")));
 };
-const ignoredDirectoryNames = new Set([
+const DEFAULT_IGNORED_DIRECTORIES = new Set([
     ".git",
     "node_modules",
     "coverage",
-    ".turbo",
     ".next",
+    ".nuxt",
+    "dist",
+    "build",
+    "out",
+    ".cache",
 ]);
-const normalizeIgnoredDirectoryNames = (directoryNames) => {
-    const normalized = new Set();
-    for (const directoryName of directoryNames) {
-        const normalizedDirectoryName = directoryName.trim().toLowerCase();
-        if (normalizedDirectoryName === "")
-            continue;
-        normalized.add(normalizedDirectoryName);
-    }
-    return normalized;
+const normalizeDirectoryName = (directoryName) => {
+    return directoryName.trim().toLowerCase();
 };
-const findAllFiles = async (directory, ignoredDirectories) => {
+const findAllFiles = async (directory, ignoredDirectoryNames) => {
     const sourceFiles = [];
     const otherFiles = [];
     const entries = await fs.readdir(directory, { withFileTypes: true });
     for (const entry of entries) {
+        if (entry.isDirectory() &&
+            ignoredDirectoryNames.has(normalizeDirectoryName(entry.name)))
+            continue;
         const fullPath = path.join(directory, entry.name);
         if (entry.isDirectory()) {
-            // Directory matching should be case-insensitive across filesystems.
-            if (ignoredDirectories.has(entry.name.toLowerCase()))
-                continue;
-            const subResult = await findAllFiles(fullPath, ignoredDirectories);
+            const subResult = await findAllFiles(fullPath, ignoredDirectoryNames);
             sourceFiles.push(...subResult.sourceFiles);
             otherFiles.push(...subResult.otherFiles);
             continue;
@@ -49,7 +46,11 @@ const findAllFiles = async (directory, ignoredDirectories) => {
     }
     return { sourceFiles, otherFiles };
 };
-export const findInputFiles = async (input, options = {}) => {
+export const findInputFiles = async (input, options) => {
+    const ignoredDirectoryNames = new Set([...DEFAULT_IGNORED_DIRECTORIES].map((directoryName) => normalizeDirectoryName(directoryName)));
+    for (const directoryName of options?.ignoredDirectoryNames ?? []) {
+        ignoredDirectoryNames.add(normalizeDirectoryName(directoryName));
+    }
     let inputStat;
     try {
         inputStat = await fs.stat(input);
@@ -60,10 +61,9 @@ export const findInputFiles = async (input, options = {}) => {
     }
     let sourceFilePaths;
     let otherFilePaths;
-    const normalizedIgnoredDirectories = normalizeIgnoredDirectoryNames(options.ignoredDirectories ?? ignoredDirectoryNames);
     try {
         if (inputStat.isDirectory()) {
-            const allFiles = await findAllFiles(input, normalizedIgnoredDirectories);
+            const allFiles = await findAllFiles(input, ignoredDirectoryNames);
             sourceFilePaths = allFiles.sourceFiles;
             otherFilePaths = allFiles.otherFiles;
         }

package/dist/cli/install-stdout-error-handler.js

@@ -1,18 +1,9 @@
-const isExpectedStdoutCloseError = (error) => {
-    if (!(error instanceof Error))
-        return false;
-    const code = "code" in error && typeof error.code === "string" ? error.code : "";
-    // Treat only broken-pipe as expected in shell pipelines (e.g. `... | head`).
-    // Other stdout errors should surface so real stream lifecycle bugs are visible.
-    return code === "EPIPE";
-};
 export const installStdoutErrorHandler = () => {
     process.stdout.on("error", (error) => {
-        if (isExpectedStdoutCloseError(error)) {
-            // Don't force `process.exit(0)` here; let Node drain/finish naturally so
-            // preceding stdout writes are not truncated in pipeline scenarios.
-            process.exitCode = 0;
-            return;
+        if (error.code === "EPIPE") {
+            // Exiting immediately prevents repeated EPIPE writes in closed pipelines.
+            // eslint-disable-next-line unicorn/no-process-exit
+            process.exit(0);
         }
         throw error;
     });

package/dist/cli/parse-cli-options.d.ts

@@ -0,0 +1,6 @@
+export type ListFormat = "text" | "tsv" | "json";
+export declare const parseIgnoredDirectories: (value: string) => string[];
+export declare const parseListFormat: (value: string) => ListFormat;
+export declare const parsePositiveInt: (value: string) => number;
+export declare const normalizeArgvForCommander: (argv: string[]) => string[];
+export declare const shouldUnsafeStabilize: (safeFlag: boolean | undefined) => boolean;

package/dist/cli/parse-cli-options.js

@@ -0,0 +1,48 @@
+import { InvalidArgumentError } from "@commander-js/extra-typings";
+export const parseIgnoredDirectories = (value) => {
+    const items = value
+        .split(",")
+        .map((item) => item.trim())
+        .filter((item) => item.length > 0);
+    if (items.length === 0) {
+        throw new InvalidArgumentError("must contain at least one directory name");
+    }
+    return items;
+};
+export const parseListFormat = (value) => {
+    if (value === "text" || value === "tsv" || value === "json")
+        return value;
+    throw new InvalidArgumentError(`invalid value '${value}' (expected: text, tsv, json)`);
+};
+export const parsePositiveInt = (value) => {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 1) {
+        throw new InvalidArgumentError("must be a positive integer");
+    }
+    return parsed;
+};
+export const normalizeArgvForCommander = (argv) => {
+    // Package managers forward args as: [..., "--", "--flag"].
+    // Strip only that forwarded sentinel at argv[2], preserving legitimate values
+    // like `--input --`.
+    if (argv[2] !== "--")
+        return argv;
+    const executablePath = argv[0];
+    const scriptPath = argv[1];
+    if (executablePath === undefined || scriptPath === undefined)
+        return argv;
+    return [executablePath, scriptPath, ...argv.slice(3)];
+};
+const isEnvironmentFalsy = (value) => {
+    if (value === undefined)
+        return false;
+    const trimmed = value.trim().toLowerCase();
+    return trimmed === "" || ["0", "false", "no"].includes(trimmed);
+};
+export const shouldUnsafeStabilize = (safeFlag) => {
+    if (safeFlag === true)
+        return false;
+    if (isEnvironmentFalsy(process.env.MINIREAD_UNSAFE_STABILIZE_TOP_LEVEL_BINDINGS))
+        return false;
+    return true;
+};

package/dist/cli/run-transforms.d.ts

@@ -3,11 +3,11 @@ export type RunnerOptions = {
     input: string;
     output: string;
     transforms: Transform[];
-    ignoredDirectories?: ReadonlySet<string>;
     transformOptions?: Record<string, unknown>;
     dryRun: boolean;
     workers: number;
     overwrite: boolean;
+    ignoreDirectories?: string[];
     verbose: boolean;
 };
 export type RunnerResult = {

package/dist/cli/run-transforms.js

@@ -11,8 +11,10 @@ const logVerbose = (verbose, message) => {
     console.error(message);
 };
 export const runTransforms = async (options) => {
-    const { input, output, transforms, ignoredDirectories, transformOptions = {}, dryRun, workers, overwrite, verbose, } = options;
-    const inputFilesResult = await findInputFiles(input, { ignoredDirectories });
+    const { input, output, transforms, transformOptions = {}, dryRun, workers, overwrite, ignoreDirectories, verbose, } = options;
+    const inputFilesResult = await findInputFiles(input, {
+        ignoredDirectoryNames: ignoreDirectories,
+    });
     if (!inputFilesResult.ok) {
         return {
             filesProcessed: 0,
@@ -27,13 +29,25 @@ export const runTransforms = async (options) => {
     }
     // Read all files in parallel
     logVerbose(verbose, "Reading files...");
-    const parsedFiles = await Promise.all(sourceFilePaths.map(async (filePath) => {
-        const content = await fs.readFile(filePath, "utf8");
-        return { path: filePath, content };
-    }));
-    // Build project graph (includes parsing)
-    logVerbose(verbose, "Parsing files with Babel...");
-    const projectGraph = buildProjectGraph(parsedFiles);
+    let projectGraph;
+    try {
+        const readQueue = new PQueue({ concurrency: workers });
+        const parsedFiles = await Promise.all(sourceFilePaths.map((filePath) => readQueue.add(async () => {
+            const content = await fs.readFile(filePath, "utf8");
+            return { path: filePath, content };
+        })));
+        // Build project graph (includes parsing)
+        logVerbose(verbose, "Parsing files with Babel...");
+        projectGraph = buildProjectGraph(parsedFiles);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            filesProcessed: 0,
+            totalTransformations: 0,
+            errors: [message],
+        };
+    }
     logVerbose(verbose, `Running ${transforms.length} transform(s) with ${workers} worker(s)...`);
     // Create a queue for parallel processing
     const queue = new PQueue({ concurrency: workers });

package/dist/cli.js

@@ -1,44 +1,121 @@
 #!/usr/bin/env node
+import { Command } from "@commander-js/extra-typings";
 import packageJson from "../package.json" with { type: "json" };
-import { createProgram, parseCliOptions } from "./cli/create-program.js";
+import { getTransformsToRun, getTransformSummaries } from "./cli/config.js";
+import { runTransforms, transformStdin } from "./cli/runner.js";
+import { getDefaultTransformOptions } from "./core/default-transform-options.js";
 import { installStdoutErrorHandler } from "./cli/install-stdout-error-handler.js";
-import { runInputMode } from "./cli/run-input-mode.js";
-import { runStdinMode } from "./cli/run-stdin-mode.js";
-import { writeTransformSummaries } from "./cli/write-transform-summaries.js";
-const program = createProgram({
-    name: packageJson.name,
-    description: packageJson.description,
-    version: packageJson.version,
-});
+import { normalizeArgvForCommander, parseIgnoredDirectories, parseListFormat, parsePositiveInt, shouldUnsafeStabilize, } from "./cli/parse-cli-options.js";
 installStdoutErrorHandler();
-const options = parseCliOptions(program);
+const program = new Command()
+    .name(packageJson.name)
+    .description(packageJson.description)
+    .version(packageJson.version)
+    .showHelpAfterError("(add --help for additional information)")
+    .showSuggestionAfterError()
+    .option("-v, --verbose", "Enable verbose output")
+    .option("-i, --input <path>", "Input file or directory (default: stdin)")
+    .option("-o, --output <path>", "Output directory (required when using --input)")
+    .option("-t, --transforms <list>", "Comma-separated list of transforms to run (or preset: recommended, all, none)")
+    .option("--list-transforms", "List available transforms")
+    .option("--format <format>", "Output format for --list-transforms: text, tsv, json", parseListFormat, "text")
+    .option("--dry-run", "Show what would be changed without writing files")
+    .option("-w, --workers <n>", "Number of parallel workers", parsePositiveInt, 4)
+    .option("-f, --overwrite", "Overwrite existing files in output directory")
+    .option("--ignore-dirs <list>", "Comma-separated directory names to ignore while scanning --input directories", parseIgnoredDirectories)
+    .option("--safe-stabilize-top-level-bindings", "Make stabilize-top-level-bindings bail out on dynamic-name hazards (safer; output more likely runnable)");
+program.addHelpText("after", `
+Examples:
+  # Read from stdin, write to stdout (filter mode)
+  cat bundle.min.js | miniread > bundle.js
+
+  # Process a directory into an output directory
+  miniread --input ./minified --output ./readable
+
+  # Use the recommended preset explicitly
+  miniread --input ./minified --output ./readable --transforms recommended
+
+  # Run all transforms (including non-recommended ones)
+  miniread --input ./minified --output ./readable --transforms all
+
+  # List available transforms (one per line)
+  miniread --list-transforms
+
+  # Pipeline example: find frequent identifiers after transforming
+  cat bundle.min.js | miniread | grep -oE '[A-Za-z_][A-Za-z0-9_]+' | sort | uniq -c | sort -rn | head -20
+`);
+program.parse(normalizeArgvForCommander(process.argv));
+const options = program.opts();
 if (options.listTransforms) {
-    writeTransformSummaries(options.format);
+    const summaries = getTransformSummaries();
+    if (options.format === "json") {
+        process.stdout.write(JSON.stringify(summaries, undefined, 2) + "\n");
+    }
+    else if (options.format === "tsv") {
+        process.stdout.write("ID\tDESCRIPTION\tSCOPE\tPARALLELIZABLE\n");
+        for (const summary of summaries) {
+            process.stdout.write(`${summary.id}\t${summary.description}\t${summary.scope}\t${summary.parallelizable}\n`);
+        }
+    }
+    else {
+        for (const summary of summaries) {
+            process.stdout.write(`${summary.id}\n`);
+        }
+    }
 }
 else if (options.input) {
-    const result = await runInputMode(options);
-    if (result.ok) {
-        process.exit(0);
+    if (!options.output) {
+        program.error("--output is required when using --input");
+        process.exit(1);
     }
-    if (result.kind === "transform-errors") {
+    const transformsResult = getTransformsToRun(options.transforms);
+    if (!transformsResult.ok) {
+        program.error(transformsResult.error);
+        process.exit(1);
+    }
+    const result = await runTransforms({
+        input: options.input,
+        output: options.output,
+        transforms: transformsResult.transforms,
+        transformOptions: {
+            ...getDefaultTransformOptions(),
+            unsafeStabilizeTopLevelBindings: shouldUnsafeStabilize(options.safeStabilizeTopLevelBindings),
+        },
+        dryRun: options.dryRun ?? false,
+        workers: options.workers,
+        overwrite: options.overwrite ?? false,
+        ignoreDirectories: options.ignoreDirs,
+        verbose: options.verbose ?? false,
+    });
+    if (result.errors.length > 0) {
         console.error("Errors:");
-        for (const error of result.details) {
+        for (const error of result.errors) {
             console.error(`- ${error}`);
         }
         console.error(`Try '${packageJson.name} --help' for details.`);
         process.exit(1);
     }
-    program.error(result.error);
-}
-else if (options.output) {
-    program.error("--output cannot be used without --input");
 }
 else {
-    const result = await runStdinMode(options);
-    if (result.ok) {
-        process.stdout.write(result.output);
+    if (options.output) {
+        program.error("--output cannot be used without --input");
     }
-    else {
-        program.error(result.error);
+    const transformsResult = getTransformsToRun(options.transforms);
+    if (!transformsResult.ok) {
+        program.error(transformsResult.error);
+        process.exit(1);
+    }
+    const result = await transformStdin({
+        transforms: transformsResult.transforms,
+        transformOptions: {
+            ...getDefaultTransformOptions(),
+            unsafeStabilizeTopLevelBindings: shouldUnsafeStabilize(options.safeStabilizeTopLevelBindings),
+        },
+        verbose: options.verbose ?? false,
+    });
+    if (!result.ok) {
+        console.error(`Error: ${result.error}`);
+        process.exit(1);
     }
+    process.stdout.write(result.output);
 }

package/dist/scripts/pick-random-transform/create-pick-random-transform-command.d.ts

@@ -0,0 +1,11 @@
+import { Command } from "@commander-js/extra-typings";
+export type PickRandomTransformCliRawOptions = {
+    verbose: boolean;
+    evaluationKey: string;
+    transformsDirectory: string;
+    top: number;
+    pick: number;
+};
+export declare const createPickRandomTransformCommand: (options: {
+    version: string;
+}) => Command;

package/dist/scripts/pick-random-transform/create-pick-random-transform-command.js

@@ -0,0 +1,30 @@
+import { Command, InvalidArgumentError } from "@commander-js/extra-typings";
+const parsePositiveInt = (rawValue) => {
+    const value = Number(rawValue);
+    if (!Number.isInteger(value) || value < 1) {
+        throw new InvalidArgumentError(`invalid value '${rawValue}' (expected a positive integer)`);
+    }
+    return value;
+};
+export const createPickRandomTransformCommand = (options) => {
+    const program = new Command()
+        .name("miniread-pick-random-transform")
+        .description("Pick random transform candidates from the slowest recommended transforms.")
+        .version(options.version)
+        .showHelpAfterError("(add --help for additional information)")
+        .showSuggestionAfterError()
+        .option("-v, --verbose", "Enable verbose output")
+        .option("--evaluation-key <key>", "Evaluation key used to read duration metrics from manifest.json", "claude-code-2.1.10:claude-code-2.1.11")
+        .option("--transforms-directory <path>", "Directory containing transform subdirectories", "src/transforms")
+        .option("--top <count>", "How many slowest eligible transforms form the candidate pool", parsePositiveInt, 10)
+        .option("--pick <count>", "How many transforms to randomly pick from the top pool", parsePositiveInt, 3);
+    program.addHelpText("after", `
+Examples:
+  # Pick 3 candidates from the 10 slowest recommended transforms
+  pnpm run miniread-pick-random-transform
+
+  # Use a different evaluation key and pool size
+  pnpm run miniread-pick-random-transform -- --evaluation-key claude-code-2.1.11:claude-code-2.1.12 --top 15 --pick 3
+`);
+    return program;
+};

package/dist/scripts/pick-random-transform/load-transform-performance-entries.d.ts

@@ -0,0 +1,5 @@
+import type { TransformPerformanceEntry } from "./pick-random-transform-candidates.js";
+export declare const loadTransformPerformanceEntries: (options: {
+    transformsDirectory: string;
+    evaluationKey: string;
+}) => TransformPerformanceEntry[];

package/dist/scripts/pick-random-transform/load-transform-performance-entries.js

@@ -0,0 +1,53 @@
+import { readFileSync, readdirSync } from "node:fs";
+import path from "node:path";
+const parseManifest = (manifestPath) => {
+    const content = readFileSync(manifestPath, "utf8");
+    const parsed = JSON.parse(content);
+    return {
+        recommended: parsed.recommended,
+        supersededBy: parsed.supersededBy,
+        evaluations: parsed.evaluations,
+    };
+};
+const parseNumber = (value) => {
+    if (typeof value !== "number")
+        return undefined;
+    if (!Number.isFinite(value))
+        return undefined;
+    return value;
+};
+export const loadTransformPerformanceEntries = (options) => {
+    const { transformsDirectory, evaluationKey } = options;
+    const directoryEntries = readdirSync(transformsDirectory, {
+        withFileTypes: true,
+    });
+    const performanceEntries = [];
+    for (const directoryEntry of directoryEntries) {
+        if (!directoryEntry.isDirectory())
+            continue;
+        const transformId = directoryEntry.name;
+        const manifestPath = path.join(transformsDirectory, transformId, "manifest.json");
+        let manifest;
+        try {
+            manifest = parseManifest(manifestPath);
+        }
+        catch (error) {
+            const code = error instanceof Error && "code" in error ? error.code : undefined;
+            if (code === "ENOENT")
+                continue;
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to parse ${manifestPath}: ${message}`);
+        }
+        const evaluation = manifest.evaluations?.[evaluationKey];
+        performanceEntries.push({
+            transformId,
+            recommended: manifest.recommended === true,
+            supersededBy: typeof manifest.supersededBy === "string"
+                ? manifest.supersededBy
+                : undefined,
+            durationSeconds: parseNumber(evaluation?.durationSeconds),
+            changedLines: parseNumber(evaluation?.changedLines),
+        });
+    }
+    return performanceEntries;
+};

package/dist/scripts/pick-random-transform/parse-pick-random-transform-cli-options.d.ts

@@ -0,0 +1,12 @@
+import type { PickRandomTransformCliRawOptions } from "./create-pick-random-transform-command.js";
+export type PickRandomTransformCliOptions = {
+    verbose: boolean;
+    evaluationKey: string;
+    transformsDirectory: string;
+    topCount: number;
+    pickCount: number;
+};
+export declare const parsePickRandomTransformCliOptions: (options: {
+    cwd: string;
+    rawOptions: PickRandomTransformCliRawOptions;
+}) => PickRandomTransformCliOptions;

package/dist/scripts/pick-random-transform/parse-pick-random-transform-cli-options.js

@@ -0,0 +1,20 @@
+import path from "node:path";
+export const parsePickRandomTransformCliOptions = (options) => {
+    const { cwd, rawOptions } = options;
+    const evaluationKey = rawOptions.evaluationKey.trim();
+    if (evaluationKey.length === 0) {
+        throw new Error("--evaluation-key must be a non-empty string");
+    }
+    const topCount = rawOptions.top;
+    const pickCount = rawOptions.pick;
+    if (pickCount > topCount) {
+        throw new Error("--pick must be less than or equal to --top");
+    }
+    return {
+        verbose: rawOptions.verbose,
+        evaluationKey,
+        transformsDirectory: path.resolve(cwd, rawOptions.transformsDirectory),
+        topCount,
+        pickCount,
+    };
+};

package/dist/scripts/pick-random-transform/pick-random-transform-candidates.d.ts

@@ -0,0 +1,26 @@
+export type RandomIntGenerator = {
+    nextInt: (maxExclusive: number) => number;
+};
+export type TransformPerformanceEntry = {
+    transformId: string;
+    recommended: boolean;
+    supersededBy: string | undefined;
+    durationSeconds: number | undefined;
+    changedLines: number | undefined;
+};
+type TransformCandidate = {
+    transformId: string;
+    durationSeconds: number;
+    changedLines: number;
+};
+type PickRandomTransformCandidatesResult = {
+    candidatePool: TransformCandidate[];
+    candidates: TransformCandidate[];
+};
+export declare const pickRandomTransformCandidates: (options: {
+    entries: TransformPerformanceEntry[];
+    topCount: number;
+    pickCount: number;
+    rng: RandomIntGenerator;
+}) => PickRandomTransformCandidatesResult;
+export {};