miniread 1.17.0 → 1.19.0

package/dist/scripts/evaluate/check-expected-evaluations.d.ts

@@ -10,7 +10,7 @@ type CheckExpectedEvaluationsResult = {
     allPresent: boolean;
 };
 type CheckExpectedEvaluationsOptions = {
-    manifestPath: string;
+    transformsDirectory: string;
     testCasesDirectory: string;
 };
 export declare const checkExpectedEvaluations: (options: CheckExpectedEvaluationsOptions) => Promise<CheckExpectedEvaluationsResult>;

package/dist/scripts/evaluate/check-expected-evaluations.js

@@ -1,19 +1,20 @@
 import * as fs from "node:fs/promises";
+import path from "node:path";
 import { allTransformIds } from "../../transforms/transform-registry.js";
 import { transformRegistry } from "../../transforms/transform-registry.js";
 import { transformPresets } from "../../transforms/transform-presets.js";
-import { parseTransformManifest } from "./parse-transform-manifest.js";
 import { checkAllSnapshots } from "./check-snapshots.js";
 export const checkExpectedEvaluations = async (options) => {
-    const { manifestPath, testCasesDirectory } = options;
+    const { transformsDirectory, testCasesDirectory } = options;
     const transformIds = allTransformIds.toSorted();
     const missingManifestEntries = [];
-    // Check manifest entries
-    const manifestContent = await fs.readFile(manifestPath, "utf8");
-    const manifest = parseTransformManifest(manifestContent);
-    const manifestIds = new Set(manifest.transforms.map((t) => t.id));
+    // Check that each transform has a manifest.json file
     for (const transformId of transformIds) {
-        if (!manifestIds.has(transformId)) {
+        const manifestPath = path.join(transformsDirectory, transformId, "manifest.json");
+        try {
+            await fs.access(manifestPath);
+        }
+        catch {
             missingManifestEntries.push({
                 transformId,
                 path: manifestPath,

package/dist/scripts/evaluate/create-evaluate-command.js

@@ -22,8 +22,7 @@ export const createEvaluateCommand = (options) => {
         .option("--write-metrics", "Write metrics JSON to the evaluation directory")
         .option("--metrics-file <path>", "Write metrics JSON to a specific path")
         .option("--write-patches", "Write baseline/test diff patches to the evaluation directory")
-        .option("-u, --update-manifest", "Update transform-manifest.json metrics (does not add new entries or edit notes)")
-        .option("--manifest-file <path>", "Path to transform-manifest.json", "transform-manifest.json")
+        .option("-u, --update-manifest", "Update manifest.json metrics for transforms (does not add new entries or edit notes)")
         .option("-f, --overwrite", "Overwrite existing metrics/patch files")
         .option("--no-format-code", "Skip formatting temp directories with Prettier before diffing")
         .option("--check", "Check that all expected evaluation metrics files exist (does not run evaluations)");

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

@@ -12,7 +12,6 @@ export type EvaluateCliRawOptions = {
     metricsFile?: string;
     writePatches?: boolean;
     updateManifest?: boolean;
-    manifestFile: string;
     overwrite?: boolean;
     formatCode: boolean;
     check?: boolean;
@@ -30,7 +29,8 @@ export type EvaluateCliOptions = {
     shouldWritePatches: boolean;
     shouldUpdateManifest: boolean;
     metricsPath: string;
-    manifestPath: string;
+    transformsDirectory: string;
+    presetStatsPath: string;
     overwrite: boolean;
     formatCode: boolean;
     baselineSlug: string;

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

@@ -77,7 +77,8 @@ export const parseEvaluateCliOptions = (options) => {
     });
     const sourcesDirectory = path.resolve(cwd, rawOptions.sources);
     const evaluationDirectory = path.resolve(cwd, rawOptions.evaluationDir);
-    const manifestPath = path.resolve(cwd, rawOptions.manifestFile);
+    const transformsDirectory = path.resolve(cwd, "src/transforms");
+    const presetStatsPath = path.resolve(cwd, "src/transforms/preset-stats.json");
     const shouldWriteMetrics = Boolean(rawOptions.writeMetrics || rawOptions.metricsFile);
     const shouldWritePatches = Boolean(rawOptions.writePatches);
     const shouldUpdateManifest = Boolean(rawOptions.updateManifest);
@@ -97,7 +98,8 @@ export const parseEvaluateCliOptions = (options) => {
         shouldWritePatches,
         shouldUpdateManifest,
         metricsPath,
-        manifestPath,
+        transformsDirectory,
+        presetStatsPath,
         overwrite,
         formatCode,
         baselineSlug,

package/dist/scripts/evaluate/run-check-mode.d.ts

@@ -1,6 +1,6 @@
 import type { OutputFormat } from "./create-evaluate-command.js";
 type RunCheckModeOptions = {
-    manifestPath: string;
+    transformsDirectory: string;
     rootDirectory: string;
     format: OutputFormat;
 };

package/dist/scripts/evaluate/run-check-mode.js

@@ -1,9 +1,9 @@
 import path from "node:path";
 import { checkExpectedEvaluations } from "./check-expected-evaluations.js";
 export const runCheckMode = async (options) => {
-    const { manifestPath, rootDirectory, format } = options;
+    const { transformsDirectory, rootDirectory, format } = options;
     const checkResult = await checkExpectedEvaluations({
-        manifestPath,
+        transformsDirectory,
         testCasesDirectory: path.join(rootDirectory, "test-cases"),
     });
     if (format === "json") {
@@ -33,11 +33,16 @@ export const runCheckMode = async (options) => {
     }
     let exitCode = 0;
     if (checkResult.missingManifestEntries.length > 0) {
-        console.error(`\n[MISSING MANIFEST ENTRIES] ${checkResult.missingManifestEntries.length} transform(s) not in transform-manifest.json:`);
+        console.error(`\n[MISSING MANIFEST FILES] ${checkResult.missingManifestEntries.length} transform(s) missing manifest.json:`);
         for (const item of checkResult.missingManifestEntries) {
             console.error(`  - ${item.transformId}`);
         }
-        console.error(`\n  To fix: Add entries manually to transform-manifest.json, or run evaluation with --update-manifest`);
+        console.error(`\n  To fix: Create a manifest.json file in each transform directory with the following structure:`);
+        console.error(`    {`);
+        console.error(`      "diffReductionImpact": 0,`);
+        console.error(`      "recommended": true,`);
+        console.error(`      "notes": "Description of the transform's impact"`);
+        console.error(`    }`);
         exitCode = 1;
     }
     const missingSnapshots = checkResult.snapshotIssues.filter((issue) => issue.issue === "missing-required");

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

@@ -1,5 +1,6 @@
 import * as fs from "node:fs/promises";
 import packageJson from "../../../package.json" with { type: "json" };
+import { transformPresets } from "../../transforms/transform-presets.js";
 import { createEvaluateCommand } from "./create-evaluate-command.js";
 import { parseEvaluateCliOptions, } from "./parse-evaluate-cli-options.js";
 import { resolveEvaluateDependencies } from "./resolve-evaluate-dependencies.js";
@@ -35,7 +36,7 @@ export const runEvaluateCli = async (argv) => {
     };
     if (parsedOptions.checkMode) {
         return runCheckMode({
-            manifestPath: parsedOptions.manifestPath,
+            transformsDirectory: parsedOptions.transformsDirectory,
             rootDirectory: process.cwd(),
             format: parsedOptions.format,
         });
@@ -100,15 +101,17 @@ export const runEvaluateCli = async (argv) => {
     }
     if (parsedOptions.shouldUpdateManifest) {
         if (errors.length > 0) {
-            console.error("Refusing to update transform-manifest.json because some evaluations failed.");
+            console.error("Refusing to update manifests because some evaluations failed.");
             exitCode = 1;
         }
         else {
             const updateResult = await updateTransformManifestFromEvaluation({
-                manifestPath: parsedOptions.manifestPath,
+                transformsDirectory: parsedOptions.transformsDirectory,
+                presetStatsPath: parsedOptions.presetStatsPath,
                 baselineTransforms: parsedOptions.baselineTransforms,
                 testTransforms: parsedOptions.testTransforms,
                 reductionRatios: results.map((r) => r.reductionRatio),
+                recommendedTransformIds: transformPresets.recommended,
             });
             console.error(updateResult.message);
         }

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

@@ -1,8 +1,10 @@
 type UpdateTransformManifestOptions = {
-    manifestPath: string;
+    transformsDirectory: string;
+    presetStatsPath: string;
     baselineTransforms: string[];
     testTransforms: string[];
     reductionRatios: number[];
+    recommendedTransformIds: string[];
 };
 export declare const updateTransformManifestFromEvaluation: (options: UpdateTransformManifestOptions) => Promise<{
     updated: boolean;

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

@@ -1,7 +1,8 @@
 import * as fs from "node:fs/promises";
+import path from "node:path";
 import { haveSameIds, normalizeTransformIds, uniqueIds, } from "./transform-id-set.js";
-import { parseTransformManifest } from "./parse-transform-manifest.js";
 import { writeJsonFileAtomic } from "./write-text-file-atomic.js";
+import presetStats from "../../transforms/preset-stats.json" with { type: "json" };
 const average = (values) => {
     if (values.length === 0)
         return 0;
@@ -11,73 +12,79 @@ const average = (values) => {
     }
     return total / values.length;
 };
-export const updateTransformManifestFromEvaluation = async (options) => {
-    const { manifestPath, baselineTransforms, testTransforms, reductionRatios } = options;
+const loadManifest = async (manifestPath) => {
     try {
-        await fs.access(manifestPath);
+        const content = await fs.readFile(manifestPath, "utf8");
+        return JSON.parse(content);
     }
-    catch {
-        return {
-            updated: false,
-            message: `Skipped updating transform-manifest.json (not found at ${manifestPath})`,
-        };
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+            return undefined;
+        }
+        throw error;
     }
-    const manifest = parseTransformManifest(await fs.readFile(manifestPath, "utf8"));
-    const existingIds = new Set(manifest.transforms.map((t) => t.id));
+};
+export const updateTransformManifestFromEvaluation = async (options) => {
+    const { transformsDirectory, presetStatsPath, baselineTransforms, testTransforms, reductionRatios, recommendedTransformIds, } = options;
     const baselineIds = normalizeTransformIds(baselineTransforms);
     const testIds = normalizeTransformIds(testTransforms);
-    const idsToUpdate = new Set([...baselineIds, ...testIds]);
-    idsToUpdate.delete("none");
-    const missingIds = [...idsToUpdate].filter((id) => !existingIds.has(id));
-    let updated = false;
     const isBaselineNone = baselineIds.length === 0 ||
         (baselineTransforms.length === 1 && baselineTransforms[0] === "none");
+    let updated = false;
+    const messages = [];
+    // Update individual transform manifest if baseline is none and we have a single test transform
     if (isBaselineNone && testIds.length === 1) {
         const transformId = testIds[0];
         if (transformId) {
-            const measuredImpact = average(reductionRatios);
-            const entry = manifest.transforms.find((t) => t.id === transformId);
-            if (entry && entry.diffReductionImpact !== measuredImpact) {
-                entry.diffReductionImpact = measuredImpact;
-                updated = true;
+            const manifestPath = path.join(transformsDirectory, transformId, "manifest.json");
+            const manifest = await loadManifest(manifestPath);
+            if (manifest) {
+                const measuredImpact = average(reductionRatios);
+                if (manifest.diffReductionImpact !== measuredImpact) {
+                    manifest.diffReductionImpact = measuredImpact;
+                    manifest.evaluatedAt = new Date().toISOString();
+                    await writeJsonFileAtomic(manifestPath, manifest, {
+                        overwrite: true,
+                    });
+                    messages.push(`Updated ${transformId}/manifest.json`);
+                    updated = true;
+                }
+            }
+            else {
+                messages.push(`Skipping update for ${transformId}: manifest.json not found at ${manifestPath}`);
             }
         }
     }
+    // Update preset stats if testing the recommended preset
     if (isBaselineNone) {
-        const recommendedIds = manifest.transforms
-            .filter((entry) => entry.recommended)
-            .map((entry) => entry.id);
         const testUniqueIds = uniqueIds(testIds);
-        const recommendedUniqueIds = uniqueIds(recommendedIds);
+        const recommendedUniqueIds = uniqueIds(recommendedTransformIds);
         if (testUniqueIds.length > 0 &&
             haveSameIds(testUniqueIds, recommendedUniqueIds)) {
             const measuredImpact = average(reductionRatios);
-            manifest.presetStats ??= {};
-            const existing = manifest.presetStats.recommended;
+            const currentStats = { ...presetStats };
+            const existing = currentStats.recommended;
             if (existing?.diffReductionImpact !== measuredImpact) {
-                manifest.presetStats.recommended = {
+                currentStats.recommended = {
                     diffReductionImpact: measuredImpact,
                     notes: `Measured with baseline none: ${(measuredImpact * 100).toFixed(2)}%.`,
                 };
+                await writeJsonFileAtomic(presetStatsPath, currentStats, {
+                    overwrite: true,
+                });
+                messages.push("Updated preset-stats.json");
                 updated = true;
             }
         }
     }
     if (!updated) {
-        const missingMessage = missingIds.length > 0
-            ? ` Missing transform entries: ${missingIds.join(", ")}. Add them to transform-manifest.json manually.`
-            : "";
         return {
             updated: false,
-            message: `transform-manifest.json already up to date.${missingMessage}`,
+            message: messages.length > 0 ? messages.join("\n") : "No updates needed.",
         };
     }
-    await writeJsonFileAtomic(manifestPath, manifest, { overwrite: true });
-    const missingMessage = missingIds.length > 0
-        ? ` Missing transform entries: ${missingIds.join(", ")}. Add them to transform-manifest.json manually.`
-        : "";
     return {
         updated: true,
-        message: `Updated transform-manifest.json.${missingMessage}`,
+        message: messages.join("\n"),
     };
 };

package/dist/scripts/snapshot/format-code.d.ts

@@ -0,0 +1 @@
+export declare const formatCode: (code: string) => Promise<string>;

package/dist/scripts/snapshot/format-code.js

@@ -0,0 +1,4 @@
+import * as prettier from "prettier";
+export const formatCode = async (code) => {
+    return prettier.format(code, { parser: "babel" });
+};

package/dist/scripts/snapshot/print-snapshot-diff.d.ts

@@ -0,0 +1,6 @@
+type PrintSnapshotDiffOptions = {
+    expectedContent: string;
+    actualOutput: string;
+};
+export declare const printSnapshotDiff: (options: PrintSnapshotDiffOptions) => void;
+export {};

package/dist/scripts/snapshot/print-snapshot-diff.js

@@ -0,0 +1,26 @@
+export const printSnapshotDiff = (options) => {
+    const { expectedContent, actualOutput } = options;
+    console.log(`\nDiff: expected vs actual`);
+    console.log("---");
+    const expectedLines = expectedContent.split("\n");
+    const actualLines = actualOutput.split("\n");
+    const maxLines = Math.max(expectedLines.length, actualLines.length);
+    for (let lineIndex = 0; lineIndex < maxLines; lineIndex++) {
+        const expectedLine = expectedLines[lineIndex];
+        const actualLine = actualLines[lineIndex];
+        if (expectedLine === actualLine)
+            continue;
+        console.log(`Line ${lineIndex + 1}:`);
+        if (expectedLine !== undefined && actualLine === undefined) {
+            console.log(`  - ${expectedLine}`);
+            continue;
+        }
+        if (expectedLine === undefined && actualLine !== undefined) {
+            console.log(`  + ${actualLine}`);
+            continue;
+        }
+        console.log(`  - ${expectedLine}`);
+        console.log(`  + ${actualLine}`);
+    }
+    console.log("---");
+};

package/dist/scripts/snapshot/resolve-testcase-input.d.ts

@@ -0,0 +1,16 @@
+type ResolveTestcaseInputOptions = {
+    testcase: string;
+};
+type ResolveTestcaseInputValue = {
+    testcaseDirectory: string;
+    basePath: string;
+};
+type Result<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: Error;
+};
+export declare const resolveTestcaseInput: (options: ResolveTestcaseInputOptions) => Promise<Result<ResolveTestcaseInputValue>>;
+export {};

package/dist/scripts/snapshot/resolve-testcase-input.js

@@ -0,0 +1,30 @@
+import * as fs from "node:fs/promises";
+import path from "node:path";
+const TEST_CASES_DIR = path.resolve(import.meta.dirname, "../../../test-cases");
+export const resolveTestcaseInput = async (options) => {
+    const { testcase } = options;
+    const testcaseDirectory = path.join(TEST_CASES_DIR, testcase);
+    try {
+        const stats = await fs.stat(testcaseDirectory);
+        if (!stats.isDirectory()) {
+            return { ok: false, error: new Error(`${testcase} is not a directory`) };
+        }
+    }
+    catch {
+        return {
+            ok: false,
+            error: new Error(`Test case directory not found: test-cases/${testcase}`),
+        };
+    }
+    const basePath = path.join(testcaseDirectory, "base.js");
+    try {
+        await fs.access(basePath);
+    }
+    catch {
+        return {
+            ok: false,
+            error: new Error(`base.js not found in test-cases/${testcase}/`),
+        };
+    }
+    return { ok: true, value: { testcaseDirectory, basePath } };
+};

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

@@ -1,75 +1,39 @@
 import * as fs from "node:fs/promises";
-import { createRequire } from "node:module";
 import path from "node:path";
-import * as prettier from "prettier";
 import packageJson from "../../../package.json" with { type: "json" };
-import { buildProjectGraph } from "../../core/project-graph.js";
-import { transformPresets } from "../../transforms/transform-presets.js";
-import { transformRegistry } from "../../transforms/transform-registry.js";
+import { formatCode } from "./format-code.js";
 import { createSnapshotCommand, } from "./create-snapshot-command.js";
-const require = createRequire(import.meta.url);
-// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-const generate = require("@babel/generator").default;
-const TEST_CASES_DIR = path.resolve(import.meta.dirname, "../../../test-cases");
-const formatCode = async (code) => prettier.format(code, { parser: "babel" });
-const runTransform = async (inputPath, transformId) => {
-    const content = await fs.readFile(inputPath, "utf8");
-    // Handle "recommended" as a special case that runs all recommended transforms
-    const transformIds = transformId === "recommended"
-        ? transformPresets.recommended
-        : [transformId];
-    const transforms = transformIds.map((id) => {
-        const transform = transformRegistry[id];
-        if (!transform) {
-            throw new Error(`Unknown transform: ${id}. Run 'miniread --list-transforms' to see available transforms.`);
-        }
-        return transform;
-    });
-    const projectGraph = buildProjectGraph([{ path: inputPath, content }]);
-    for (const transform of transforms) {
-        await transform.transform({
-            projectGraph,
-            currentFile: undefined,
-            options: {},
-        });
-    }
-    const fileInfo = projectGraph.files.get(inputPath);
-    if (!fileInfo) {
-        return content;
-    }
-    return generate(fileInfo.ast).code;
-};
+import { printSnapshotDiff } from "./print-snapshot-diff.js";
+import { resolveTestcaseInput } from "./resolve-testcase-input.js";
+import { runTestcaseTransform } from "./run-testcase-transform.js";
 export const runSnapshotCli = async (argv) => {
     const program = createSnapshotCommand({ version: packageJson.version });
     program.parse(argv.filter((argument) => argument !== "--"));
     const rawOptions = program.opts();
     const { testcase, transform, expected } = rawOptions;
-    // Validate test case directory exists
-    const testCaseDirectory = path.join(TEST_CASES_DIR, testcase);
-    try {
-        const stats = await fs.stat(testCaseDirectory);
-        if (!stats.isDirectory()) {
-            console.error(`Error: ${testcase} is not a directory`);
+    const resolved = await resolveTestcaseInput({ testcase });
+    if (!resolved.ok) {
+        const message = resolved.error.message;
+        if (message === `${testcase} is not a directory`) {
+            console.error(`Error: ${message}`);
             return 1;
         }
-    }
-    catch {
-        console.error(`Error: Test case directory not found: test-cases/${testcase}`);
-        console.error(`Create it first: mkdir -p test-cases/${testcase}`);
-        return 1;
-    }
-    // Validate base.js exists
-    const basePath = path.join(testCaseDirectory, "base.js");
-    try {
-        await fs.access(basePath);
-    }
-    catch {
-        console.error(`Error: base.js not found in test-cases/${testcase}/`);
-        console.error(`Create test-cases/${testcase}/base.js with your minified snippet first.`);
+        if (message.startsWith("Test case directory not found:")) {
+            console.error(`Error: ${message}`);
+            console.error(`Create it first: mkdir -p test-cases/${testcase}`);
+            return 1;
+        }
+        if (message.startsWith("base.js not found in test-cases/")) {
+            console.error(`Error: ${message}`);
+            console.error(`Create test-cases/${testcase}/base.js with your minified snippet first.`);
+            return 1;
+        }
+        console.error(`Error: ${message}`);
         return 1;
     }
-    const expectedPath = path.join(testCaseDirectory, `${transform}-expected.js`);
-    const actualPath = path.join(testCaseDirectory, `${transform}.js`);
+    const { testcaseDirectory, basePath } = resolved.value;
+    const expectedPath = path.join(testcaseDirectory, `${transform}-expected.js`);
+    const actualPath = path.join(testcaseDirectory, `${transform}.js`);
     if (expected) {
         // Expected-file workflow
         // Step 1: Check if expected file exists, create from base.js if not
@@ -83,69 +47,53 @@ export const runSnapshotCli = async (argv) => {
             await fs.writeFile(expectedPath, formattedBase);
             console.log(`Created: test-cases/${testcase}/${transform}-expected.js`);
             console.log("Edit this file to match your expected output, then re-run.");
+            // Design phase: allow creating the expected file before the transform exists.
+            // The next run (after implementing the transform) will write the actual output
+            // and compare it against this expected snapshot.
             return 0;
         }
-    }
-    // Common path: Run the transform, format, and write actual output
-    let actualOutput;
-    try {
-        const rawOutput = await runTransform(basePath, transform);
-        actualOutput = await formatCode(rawOutput);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        console.error(`Error running transform: ${message}`);
-        return 1;
-    }
-    await fs.writeFile(actualPath, actualOutput);
-    console.log(`Created: test-cases/${testcase}/${transform}.js`);
-    if (!expected) {
-        return 0;
-    }
-    // Step 3: Compare expected vs actual
-    const expectedContent = await fs.readFile(expectedPath, "utf8");
-    if (expectedContent === actualOutput) {
-        // Success! Delete expected file
-        await fs.unlink(expectedPath);
-        console.log(`\nSuccess: Output matches expected.`);
-        console.log(`Deleted: test-cases/${testcase}/${transform}-expected.js`);
-        console.log(`\nSnapshot ready: test-cases/${testcase}/${transform}.js`);
-        return 0;
-    }
-    // Diff - show the difference
-    console.log(`\nDiff: expected vs actual`);
-    console.log("---");
-    // Simple line-by-line diff output
-    const expectedLines = expectedContent.split("\n");
-    const actualLines = actualOutput.split("\n");
-    const maxLines = Math.max(expectedLines.length, actualLines.length);
-    let hasDiff = false;
-    for (let lineIndex = 0; lineIndex < maxLines; lineIndex++) {
-        const exp = expectedLines[lineIndex];
-        const act = actualLines[lineIndex];
-        if (exp !== act) {
-            hasDiff = true;
-            if (exp !== undefined && act === undefined) {
-                console.log(`Line ${lineIndex + 1}:`);
-                console.log(`  - ${exp}`);
-            }
-            else if (exp === undefined && act !== undefined) {
-                console.log(`Line ${lineIndex + 1}:`);
-                console.log(`  + ${act}`);
-            }
-            else {
-                console.log(`Line ${lineIndex + 1}:`);
-                console.log(`  - ${exp}`);
-                console.log(`  + ${act}`);
-            }
+        const outputResult = await runTestcaseTransform({
+            inputPath: basePath,
+            transformId: transform,
+        });
+        if (!outputResult.ok) {
+            console.error(`Error running transform: ${outputResult.error.message}`);
+            return 1;
+        }
+        const actualOutput = outputResult.value;
+        // Step 2: Write actual output
+        await fs.writeFile(actualPath, actualOutput);
+        console.log(`Created: test-cases/${testcase}/${transform}.js`);
+        // Step 3: Compare expected vs actual
+        const expectedContent = await fs.readFile(expectedPath, "utf8");
+        if (expectedContent === actualOutput) {
+            // Success! Delete expected file
+            await fs.unlink(expectedPath);
+            console.log(`\nSuccess: Output matches expected.`);
+            console.log(`Deleted: test-cases/${testcase}/${transform}-expected.js`);
+            console.log(`\nSnapshot ready: test-cases/${testcase}/${transform}.js`);
+            return 0;
+        }
+        else {
+            printSnapshotDiff({ expectedContent, actualOutput });
+            console.log(`\nExpected file preserved: test-cases/${testcase}/${transform}-expected.js`);
+            console.log("Fix the implementation or update the expected file, then re-run.");
+            return 1;
         }
     }
-    if (!hasDiff) {
-        // Shouldn't happen since we already checked equality, but just in case
-        console.log("(no visible differences)");
+    else {
+        const outputResult = await runTestcaseTransform({
+            inputPath: basePath,
+            transformId: transform,
+        });
+        if (!outputResult.ok) {
+            console.error(`Error running transform: ${outputResult.error.message}`);
+            return 1;
+        }
+        const actualOutput = outputResult.value;
+        // Simple mode: just write actual output
+        await fs.writeFile(actualPath, actualOutput);
+        console.log(`Created: test-cases/${testcase}/${transform}.js`);
+        return 0;
     }
-    console.log("---");
-    console.log(`\nExpected file preserved: test-cases/${testcase}/${transform}-expected.js`);
-    console.log("Fix the implementation or update the expected file, then re-run.");
-    return 1;
 };

package/dist/scripts/snapshot/run-testcase-transform.d.ts

@@ -0,0 +1,13 @@
+type Result<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: Error;
+};
+type RunTestcaseTransformOptions = {
+    inputPath: string;
+    transformId: string;
+};
+export declare const runTestcaseTransform: (options: RunTestcaseTransformOptions) => Promise<Result<string>>;
+export {};