miniread 1.0.0

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

@@ -0,0 +1,97 @@
+import path from "node:path";
+import { transformPresets } from "../../transforms/transform-presets.js";
+import { allTransformIds } from "../../transforms/transform-registry.js";
+import { createTransformSlug } from "./diff-utilities.js";
+import { sanitizeFileComponent } from "./sanitize.js";
+const parseTransformList = (value) => {
+    if (!value || value === "none")
+        return [];
+    const ids = value
+        .split(",")
+        .map((id) => id.trim())
+        .filter(Boolean)
+        .filter((id) => id !== "none");
+    const expandedIds = [];
+    for (const id of ids) {
+        if (id === "recommended" || id === "default") {
+            expandedIds.push(...transformPresets.recommended);
+            continue;
+        }
+        if (id === "all") {
+            expandedIds.push(...allTransformIds);
+            continue;
+        }
+        expandedIds.push(id);
+    }
+    const uniqueIds = [];
+    const seen = new Set();
+    for (const id of expandedIds) {
+        if (seen.has(id))
+            continue;
+        seen.add(id);
+        uniqueIds.push(id);
+    }
+    return uniqueIds;
+};
+const containsPathSeparator = (value) => {
+    return value.includes("/") || value.includes("\\");
+};
+const parseComparePair = (value) => {
+    const [fromRaw, toRaw] = value.split(":");
+    const from = fromRaw?.trim();
+    const to = toRaw?.trim();
+    if (!from || !to) {
+        throw new Error(`invalid compare format '${value}' (expected: from:to)`);
+    }
+    if (from === "." || from === ".." || containsPathSeparator(from)) {
+        throw new Error(`invalid 'from' value '${from}' (expected a directory name under --sources)`);
+    }
+    if (to === "." || to === ".." || containsPathSeparator(to)) {
+        throw new Error(`invalid 'to' value '${to}' (expected a directory name under --sources)`);
+    }
+    return { from, to };
+};
+export const parseEvaluateCliOptions = (options) => {
+    const { cwd, rawOptions } = options;
+    if (rawOptions.compare.length === 0) {
+        throw new Error("at least one --compare flag is required");
+    }
+    const pairs = [];
+    for (const value of rawOptions.compare) {
+        pairs.push(parseComparePair(value));
+    }
+    const baselineTransforms = parseTransformList(rawOptions.baseline);
+    const testTransforms = parseTransformList(rawOptions.test);
+    const verbose = rawOptions.verbose ?? false;
+    const overwrite = rawOptions.overwrite ?? false;
+    const formatCode = rawOptions.formatCode;
+    const baselineSlug = sanitizeFileComponent(createTransformSlug(baselineTransforms));
+    const testSlug = sanitizeFileComponent(createTransformSlug(testTransforms));
+    const sourcesDirectory = path.resolve(cwd, rawOptions.sources);
+    const evaluationDirectory = path.resolve(cwd, rawOptions.evaluationDir);
+    const manifestPath = path.resolve(cwd, rawOptions.manifestFile);
+    const shouldWriteMetrics = Boolean(rawOptions.writeMetrics || rawOptions.metricsFile);
+    const shouldWritePatches = Boolean(rawOptions.writePatches);
+    const shouldUpdateManifest = Boolean(rawOptions.updateManifest);
+    const metricsPath = rawOptions.metricsFile
+        ? path.resolve(cwd, rawOptions.metricsFile)
+        : path.join(evaluationDirectory, `metrics-${baselineSlug}-vs-${testSlug}.json`);
+    return {
+        verbose,
+        pairs,
+        baselineTransforms,
+        testTransforms,
+        sourcesDirectory,
+        evaluationDirectory,
+        format: rawOptions.format,
+        shouldWriteMetrics,
+        shouldWritePatches,
+        shouldUpdateManifest,
+        metricsPath,
+        manifestPath,
+        overwrite,
+        formatCode,
+        baselineSlug,
+        testSlug,
+    };
+};

package/dist/scripts/evaluate/parse-transform-manifest.d.ts

@@ -0,0 +1,22 @@
+import type { Transform } from "../../core/types.js";
+type TransformManifestEntry = {
+    id: string;
+    description: string;
+    iteration: number;
+    scope: Transform["scope"];
+    parallelizable: boolean;
+    diffReductionImpact: number;
+    enabledByDefault: boolean;
+    notes?: string;
+    supersededBy?: string;
+};
+type PresetStatsEntry = {
+    diffReductionImpact: number;
+    notes?: string;
+};
+type TransformManifest = {
+    transforms: TransformManifestEntry[];
+    presetStats?: Record<string, PresetStatsEntry>;
+};
+export declare const parseTransformManifest: (raw: string) => TransformManifest;
+export {};

package/dist/scripts/evaluate/parse-transform-manifest.js

@@ -0,0 +1,29 @@
+import * as z from "zod";
+const TransformManifestEntrySchema = z
+    .object({
+    id: z.string().min(1),
+    description: z.string(),
+    iteration: z.number().int().nonnegative(),
+    scope: z.union([z.literal("file"), z.literal("project")]),
+    parallelizable: z.boolean(),
+    diffReductionImpact: z.number(),
+    enabledByDefault: z.boolean(),
+    notes: z.string().optional(),
+    supersededBy: z.string().min(1).optional(),
+})
+    .loose();
+const PresetStatsEntrySchema = z
+    .object({
+    diffReductionImpact: z.number(),
+    notes: z.string().optional(),
+})
+    .loose();
+const TransformManifestSchema = z
+    .object({
+    transforms: z.array(TransformManifestEntrySchema),
+    presetStats: z.record(z.string(), PresetStatsEntrySchema).optional(),
+})
+    .loose();
+export const parseTransformManifest = (raw) => {
+    return TransformManifestSchema.parse(JSON.parse(raw));
+};

package/dist/scripts/evaluate/resolve-evaluate-dependencies.d.ts

@@ -0,0 +1,9 @@
+export type EvaluateDependencies = {
+    diffPath: string;
+    pnpmPath: string | undefined;
+    prettierPath: string | undefined;
+};
+export declare const resolveEvaluateDependencies: (options: {
+    cwd: string;
+    formatCode: boolean;
+}) => EvaluateDependencies;

package/dist/scripts/evaluate/resolve-evaluate-dependencies.js

@@ -0,0 +1,66 @@
+import { spawnSync } from "node:child_process";
+const checkDependency = (options) => {
+    const { name, command, args, envVar, installHint, cwd } = options;
+    const result = spawnSync(command, args, { cwd, stdio: "ignore" });
+    if (!result.error && result.status === 0)
+        return;
+    const errorMessage = result.error instanceof Error
+        ? result.error.message
+        : `exit code ${result.status ?? "unknown"}`;
+    throw new Error([
+        `Error: Required dependency '${name}' not available.`,
+        `Looked for: ${command}`,
+        `Reason: ${errorMessage}`,
+        "",
+        "To fix, either:",
+        `  1. Install it: ${installHint}`,
+        `  2. Set ${envVar}=/path/to/${name}`,
+        "",
+        "Try 'miniread-evaluate --help' for details.",
+    ].join("\n"));
+};
+export const resolveEvaluateDependencies = (options) => {
+    const { cwd, formatCode } = options;
+    const diffPath = process.env.MINIREAD_EVALUATE_DIFF_PATH ?? "diff";
+    checkDependency({
+        name: "diff",
+        command: diffPath,
+        args: ["--version"],
+        envVar: "MINIREAD_EVALUATE_DIFF_PATH",
+        installHint: "install diffutils (provides 'diff')",
+        cwd,
+    });
+    if (!formatCode) {
+        return { diffPath, pnpmPath: undefined, prettierPath: undefined };
+    }
+    const prettierPath = process.env.MINIREAD_EVALUATE_PRETTIER_PATH;
+    if (prettierPath) {
+        checkDependency({
+            name: "prettier",
+            command: prettierPath,
+            args: ["--version"],
+            envVar: "MINIREAD_EVALUATE_PRETTIER_PATH",
+            installHint: "install Prettier (e.g. `pnpm install` in this repo)",
+            cwd,
+        });
+        return { diffPath, pnpmPath: undefined, prettierPath };
+    }
+    const pnpmPath = process.env.MINIREAD_EVALUATE_PNPM_PATH ?? "pnpm";
+    checkDependency({
+        name: "pnpm",
+        command: pnpmPath,
+        args: ["--version"],
+        envVar: "MINIREAD_EVALUATE_PNPM_PATH",
+        installHint: "install pnpm (https://pnpm.io/installation)",
+        cwd,
+    });
+    checkDependency({
+        name: "prettier",
+        command: pnpmPath,
+        args: ["exec", "prettier", "--version"],
+        envVar: "MINIREAD_EVALUATE_PNPM_PATH",
+        installHint: "run `pnpm install` (prettier is a devDependency in this repo)",
+        cwd,
+    });
+    return { diffPath, pnpmPath, prettierPath: undefined };
+};

package/dist/scripts/evaluate/run-evaluate-cli.d.ts

@@ -0,0 +1 @@
+export declare const runEvaluateCli: (argv: string[]) => Promise<number>;

package/dist/scripts/evaluate/run-evaluate-cli.js

@@ -0,0 +1,112 @@
+import * as fs from "node:fs/promises";
+import packageJson from "../../../package.json" with { type: "json" };
+import { transformRegistry } from "../../transforms/transform-registry.js";
+import { createEvaluateCommand } from "./create-evaluate-command.js";
+import { parseEvaluateCliOptions, } from "./parse-evaluate-cli-options.js";
+import { resolveEvaluateDependencies } from "./resolve-evaluate-dependencies.js";
+import { runEvaluations } from "./run-evaluations.js";
+import { writeEvaluationStdout } from "./write-evaluation-stdout.js";
+import { updateTransformManifestFromEvaluation } from "./transform-manifest.js";
+import { writeJsonFileAtomic } from "./write-text-file-atomic.js";
+export const runEvaluateCli = async (argv) => {
+    const program = createEvaluateCommand({ version: packageJson.version });
+    // Package managers often pass a standalone `--` to separate script args.
+    // Commander treats `--` as "end of options", which would cause flags like
+    // `--help` to be parsed as positional arguments. Strip it for robustness.
+    program.parse(argv.filter((argument) => argument !== "--"));
+    const rawOptions = program.opts();
+    let parsedOptions;
+    try {
+        parsedOptions = parseEvaluateCliOptions({
+            cwd: process.cwd(),
+            rawOptions,
+        });
+    }
+    catch (error) {
+        program.error(error instanceof Error ? error.message : String(error));
+        return 1;
+    }
+    let exitCode = 0;
+    const log = (message) => {
+        if (!parsedOptions.verbose)
+            return;
+        console.error(message);
+    };
+    let dependencies;
+    try {
+        dependencies = resolveEvaluateDependencies({
+            cwd: process.cwd(),
+            formatCode: parsedOptions.formatCode,
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(message);
+        return 1;
+    }
+    if (parsedOptions.shouldWriteMetrics || parsedOptions.shouldWritePatches) {
+        await fs.mkdir(parsedOptions.evaluationDirectory, { recursive: true });
+    }
+    const { results, errors, outcomes } = await runEvaluations({
+        pairs: parsedOptions.pairs,
+        baselineTransforms: parsedOptions.baselineTransforms,
+        testTransforms: parsedOptions.testTransforms,
+        sourcesDirectory: parsedOptions.sourcesDirectory,
+        evaluationDirectory: parsedOptions.evaluationDirectory,
+        shouldWritePatches: parsedOptions.shouldWritePatches,
+        baselineSlug: parsedOptions.baselineSlug,
+        testSlug: parsedOptions.testSlug,
+        overwrite: parsedOptions.overwrite,
+        formatCode: parsedOptions.formatCode,
+        verbose: parsedOptions.verbose,
+        log,
+        dependencies,
+        rootDirectory: process.cwd(),
+    });
+    const report = {
+        version: packageJson.version,
+        baselineTransforms: parsedOptions.baselineTransforms,
+        testTransforms: parsedOptions.testTransforms,
+        pairs: parsedOptions.pairs,
+        results,
+        errors,
+    };
+    writeEvaluationStdout({
+        format: parsedOptions.format,
+        report,
+        outcomes,
+    });
+    if (parsedOptions.shouldWriteMetrics) {
+        try {
+            await writeJsonFileAtomic(parsedOptions.metricsPath, report, {
+                overwrite: parsedOptions.overwrite,
+            });
+            log(`Wrote ${parsedOptions.metricsPath}`);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(`Error writing metrics: ${message}`);
+            exitCode = 1;
+        }
+    }
+    if (parsedOptions.shouldUpdateManifest) {
+        if (errors.length > 0) {
+            console.error("Refusing to update transform-manifest.json because some evaluations failed.");
+            exitCode = 1;
+        }
+        else {
+            const updateResult = await updateTransformManifestFromEvaluation({
+                manifestPath: parsedOptions.manifestPath,
+                baselineTransforms: parsedOptions.baselineTransforms,
+                testTransforms: parsedOptions.testTransforms,
+                reductionRatios: results.map((r) => r.reductionRatio),
+                transformRegistry,
+            });
+            console.error(updateResult.message);
+        }
+    }
+    if (errors.length > 0) {
+        exitCode = 1;
+    }
+    return exitCode;
+};

package/dist/scripts/evaluate/run-evaluations.d.ts

@@ -0,0 +1,25 @@
+import type { ComparisonPair, EvaluationResult } from "./evaluation-types.js";
+import type { EvaluationError, EvaluationOutcome } from "./evaluation-report.js";
+import type { EvaluateDependencies } from "./resolve-evaluate-dependencies.js";
+type RunEvaluationsResult = {
+    results: EvaluationResult[];
+    errors: EvaluationError[];
+    outcomes: EvaluationOutcome[];
+};
+export declare const runEvaluations: (options: {
+    pairs: ComparisonPair[];
+    baselineTransforms: string[];
+    testTransforms: string[];
+    sourcesDirectory: string;
+    evaluationDirectory: string;
+    shouldWritePatches: boolean;
+    baselineSlug: string;
+    testSlug: string;
+    overwrite: boolean;
+    formatCode: boolean;
+    verbose: boolean;
+    log: (message: string) => void;
+    dependencies: EvaluateDependencies;
+    rootDirectory: string;
+}) => Promise<RunEvaluationsResult>;
+export {};

package/dist/scripts/evaluate/run-evaluations.js

@@ -0,0 +1,50 @@
+import path from "node:path";
+import { evaluatePair } from "./pair-evaluator.js";
+import { sanitizeFileComponent } from "./sanitize.js";
+export const runEvaluations = async (options) => {
+    const { pairs, baselineTransforms, testTransforms, sourcesDirectory, evaluationDirectory, shouldWritePatches, baselineSlug, testSlug, overwrite, formatCode, verbose, log, dependencies, rootDirectory, } = options;
+    const results = [];
+    const errors = [];
+    const outcomes = [];
+    for (const pair of pairs) {
+        const safeFrom = sanitizeFileComponent(pair.from);
+        const safeTo = sanitizeFileComponent(pair.to);
+        const filePrefix = `metrics-${baselineSlug}-vs-${testSlug}_${safeFrom}_${safeTo}`;
+        const baselinePatchPath = shouldWritePatches
+            ? path.join(evaluationDirectory, `${filePrefix}_baseline.patch`)
+            : undefined;
+        const testPatchPath = shouldWritePatches
+            ? path.join(evaluationDirectory, `${filePrefix}_test.patch`)
+            : undefined;
+        try {
+            const result = await evaluatePair({
+                pair,
+                baselineTransforms,
+                testTransforms,
+                sourcesDirectory,
+                rootDirectory,
+                nodePath: process.execPath,
+                minireadCliPath: process.env.MINIREAD_EVALUATE_MINIREAD_PATH ?? "bin/miniread",
+                diffPath: dependencies.diffPath,
+                pnpmPath: dependencies.pnpmPath,
+                prettierPath: dependencies.prettierPath,
+                formatCode,
+                baselinePatchPath,
+                testPatchPath,
+                overwrite,
+                verbose,
+                log,
+            });
+            results.push(result);
+            outcomes.push({ ok: true, pair, result });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const entry = { pair, error: message };
+            errors.push(entry);
+            outcomes.push({ ok: false, pair, error: message });
+            console.error(`Error evaluating ${pair.from} -> ${pair.to}: ${message}`);
+        }
+    }
+    return { results, errors, outcomes };
+};

package/dist/scripts/evaluate/run-pair-transformations.d.ts

@@ -0,0 +1,21 @@
+import type { ComparisonPair } from "./evaluation-types.js";
+type PairTransformOutputs = {
+    sourceDirectoryFrom: string;
+    sourceDirectoryTo: string;
+    baselineOutputFrom: string;
+    baselineOutputTo: string;
+    testOutputFrom: string;
+    testOutputTo: string;
+};
+export declare const runPairTransformations: (options: {
+    pair: ComparisonPair;
+    baselineTransforms: string[];
+    testTransforms: string[];
+    sourcesDirectory: string;
+    temporaryDirectory: string;
+    rootDirectory: string;
+    nodePath: string;
+    minireadCliPath: string;
+    verbose: boolean;
+}) => Promise<PairTransformOutputs>;
+export {};

package/dist/scripts/evaluate/run-pair-transformations.js

@@ -0,0 +1,57 @@
+import path from "node:path";
+import { runMiniread } from "./shell-utilities.js";
+export const runPairTransformations = async (options) => {
+    const { pair, baselineTransforms, testTransforms, sourcesDirectory, temporaryDirectory, rootDirectory, nodePath, minireadCliPath, verbose, } = options;
+    const sourceDirectoryFrom = path.join(sourcesDirectory, pair.from);
+    const sourceDirectoryTo = path.join(sourcesDirectory, pair.to);
+    const baselineOutputFrom = path.join(temporaryDirectory, `baseline-${pair.from}`);
+    const baselineOutputTo = path.join(temporaryDirectory, `baseline-${pair.to}`);
+    const testOutputFrom = path.join(temporaryDirectory, `test-${pair.from}`);
+    const testOutputTo = path.join(temporaryDirectory, `test-${pair.to}`);
+    await Promise.all([
+        runMiniread({
+            inputDirectory: sourceDirectoryFrom,
+            outputDirectory: baselineOutputFrom,
+            transforms: baselineTransforms,
+            rootDirectory,
+            nodePath,
+            minireadCliPath,
+            verbose,
+        }),
+        runMiniread({
+            inputDirectory: sourceDirectoryTo,
+            outputDirectory: baselineOutputTo,
+            transforms: baselineTransforms,
+            rootDirectory,
+            nodePath,
+            minireadCliPath,
+            verbose,
+        }),
+        runMiniread({
+            inputDirectory: sourceDirectoryFrom,
+            outputDirectory: testOutputFrom,
+            transforms: testTransforms,
+            rootDirectory,
+            nodePath,
+            minireadCliPath,
+            verbose,
+        }),
+        runMiniread({
+            inputDirectory: sourceDirectoryTo,
+            outputDirectory: testOutputTo,
+            transforms: testTransforms,
+            rootDirectory,
+            nodePath,
+            minireadCliPath,
+            verbose,
+        }),
+    ]);
+    return {
+        sourceDirectoryFrom,
+        sourceDirectoryTo,
+        baselineOutputFrom,
+        baselineOutputTo,
+        testOutputFrom,
+        testOutputTo,
+    };
+};

package/dist/scripts/evaluate/sanitize.d.ts

@@ -0,0 +1,2 @@
+export declare const sanitizeFileComponent: (value: string) => string;
+export declare const sanitizeTsvField: (value: string) => string;

package/dist/scripts/evaluate/sanitize.js

@@ -0,0 +1,6 @@
+export const sanitizeFileComponent = (value) => {
+    return value.replaceAll(/[^\w.-]/gu, "_");
+};
+export const sanitizeTsvField = (value) => {
+    return value.replaceAll(/\r?\n/gu, " ").replaceAll("\t", " ").trim();
+};

package/dist/scripts/evaluate/shell-utilities.d.ts

@@ -0,0 +1,15 @@
+export declare const runMiniread: (options: {
+    inputDirectory: string;
+    outputDirectory: string;
+    transforms: string[];
+    rootDirectory: string;
+    nodePath: string;
+    minireadCliPath: string;
+    verbose: boolean;
+}) => Promise<void>;
+export declare const formatDirectoryWithPrettier: (options: {
+    directory: string;
+    rootDirectory: string;
+    pnpmPath: string | undefined;
+    prettierPath: string | undefined;
+}) => Promise<void>;

package/dist/scripts/evaluate/shell-utilities.js

@@ -0,0 +1,68 @@
+import { spawn } from "node:child_process";
+import path from "node:path";
+const runCommand = async (command, commandArguments, options) => {
+    const processResult = spawn(command, commandArguments, {
+        cwd: options.cwd,
+        stdio: ["ignore", "ignore", "pipe"],
+    });
+    const stderrChunks = [];
+    processResult.stderr.setEncoding("utf8");
+    processResult.stderr.on("data", (chunk) => {
+        if (stderrChunks.join("").length > 200_000)
+            return;
+        stderrChunks.push(chunk);
+    });
+    const exitCode = await new Promise((resolve, reject) => {
+        processResult.on("error", reject);
+        processResult.on("close", (code) => {
+            resolve(code);
+        });
+    });
+    if (exitCode === 0)
+        return;
+    const stderr = stderrChunks.join("").trim();
+    const stderrSuffix = stderr ? `\n\nstderr:\n${stderr}` : "";
+    throw new Error(`Command failed (${options.label}, exit code ${exitCode}).${stderrSuffix}`);
+};
+export const runMiniread = async (options) => {
+    const { inputDirectory, outputDirectory, transforms, rootDirectory, nodePath, minireadCliPath, verbose, } = options;
+    const packageRootDirectory = path.resolve(import.meta.dirname, "../../..");
+    const resolvedMinireadPath = path.isAbsolute(minireadCliPath)
+        ? minireadCliPath
+        : path.join(packageRootDirectory, minireadCliPath);
+    const transformsValue = transforms.length === 0 ? "none" : transforms.join(",");
+    const minireadArguments = [
+        resolvedMinireadPath,
+        "-i",
+        inputDirectory,
+        "-o",
+        outputDirectory,
+        "--transforms",
+        transformsValue,
+    ];
+    if (verbose)
+        minireadArguments.push("--verbose");
+    await runCommand(nodePath, minireadArguments, {
+        cwd: rootDirectory,
+        label: "miniread",
+    });
+};
+export const formatDirectoryWithPrettier = async (options) => {
+    const { directory, rootDirectory, pnpmPath, prettierPath } = options;
+    if (prettierPath) {
+        await runCommand(prettierPath, ["--write", "--ignore-unknown", "--print-width", "9999", directory], { cwd: rootDirectory, label: "prettier" });
+        return;
+    }
+    if (!pnpmPath) {
+        throw new Error("Unable to format: missing pnpmPath and prettierPath (this is a bug).");
+    }
+    await runCommand(pnpmPath, [
+        "exec",
+        "prettier",
+        "--write",
+        "--ignore-unknown",
+        "--print-width",
+        "9999",
+        directory,
+    ], { cwd: rootDirectory, label: "pnpm exec prettier" });
+};

package/dist/scripts/evaluate/transform-id-set.d.ts

@@ -0,0 +1,3 @@
+export declare const normalizeTransformIds: (ids: string[]) => string[];
+export declare const uniqueIds: (ids: string[]) => string[];
+export declare const haveSameIds: (left: string[], right: string[]) => boolean;

package/dist/scripts/evaluate/transform-id-set.js

@@ -0,0 +1,29 @@
+export const normalizeTransformIds = (ids) => {
+    return ids
+        .map((id) => id.trim())
+        .filter(Boolean)
+        .filter((id) => id !== "none");
+};
+export const uniqueIds = (ids) => {
+    const unique = [];
+    const seen = new Set();
+    for (const id of ids) {
+        if (seen.has(id))
+            continue;
+        seen.add(id);
+        unique.push(id);
+    }
+    return unique;
+};
+export const haveSameIds = (left, right) => {
+    if (left.length !== right.length)
+        return false;
+    const leftSet = new Set(left);
+    if (leftSet.size !== left.length)
+        return false;
+    for (const id of right) {
+        if (!leftSet.has(id))
+            return false;
+    }
+    return true;
+};

package/dist/scripts/evaluate/transform-manifest.d.ts

@@ -0,0 +1,13 @@
+import type { Transform } from "../../core/types.js";
+type UpdateTransformManifestOptions = {
+    manifestPath: string;
+    baselineTransforms: string[];
+    testTransforms: string[];
+    reductionRatios: number[];
+    transformRegistry: Record<string, Transform>;
+};
+export declare const updateTransformManifestFromEvaluation: (options: UpdateTransformManifestOptions) => Promise<{
+    updated: boolean;
+    message: string;
+}>;
+export {};