miniread 1.6.0 → 1.8.0

package/bin/miniread-snapshot

@@ -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/snapshot.js");
+} catch (error) {
+  console.error(
+    "Failed to start miniread-snapshot:",
+    error instanceof Error ? error.message : error,
+  );
+  process.exitCode = 1;
+}

package/dist/core/normalize-code.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Normalizes JavaScript/TypeScript code through the parse → generate → format pipeline.
+ *
+ * This ensures consistent whitespace and formatting regardless of the original source.
+ * Use this when comparing code that may have gone through different pipelines
+ * (e.g., comparing base.js to transform output).
+ *
+ * The pipeline:
+ * 1. Parse with Babel (normalizes AST structure)
+ * 2. Generate with Babel (produces consistent whitespace)
+ * 3. Format with Prettier (final formatting)
+ */
+/**
+ * Normalizes code through parse → generate → format pipeline.
+ * Returns the normalized code string.
+ */
+export declare const normalizeCode: (code: string) => Promise<string>;

package/dist/core/normalize-code.js

@@ -0,0 +1,35 @@
+/**
+ * Normalizes JavaScript/TypeScript code through the parse → generate → format pipeline.
+ *
+ * This ensures consistent whitespace and formatting regardless of the original source.
+ * Use this when comparing code that may have gone through different pipelines
+ * (e.g., comparing base.js to transform output).
+ *
+ * The pipeline:
+ * 1. Parse with Babel (normalizes AST structure)
+ * 2. Generate with Babel (produces consistent whitespace)
+ * 3. Format with Prettier (final formatting)
+ */
+import { createRequire } from "node:module";
+import * as prettier from "prettier";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const parser = require("@babel/parser");
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const parse = parser.parse;
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const generate = require("@babel/generator").default;
+const PARSER_OPTIONS = {
+    sourceType: "unambiguous",
+    plugins: ["jsx", "typescript", "importAttributes"],
+};
+/**
+ * Normalizes code through parse → generate → format pipeline.
+ * Returns the normalized code string.
+ */
+export const normalizeCode = async (code) => {
+    const ast = parse(code, PARSER_OPTIONS);
+    const generated = generate(ast);
+    const formatted = await prettier.format(generated.code, { parser: "babel" });
+    return formatted;
+};

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

@@ -0,0 +1,61 @@
+/**
+ * Helpers for the stable name prefix convention (§5.6-5.9 in workflow.md).
+ *
+ * The `$` prefix signals that a variable has been renamed stably by a transform
+ * and should be skipped by other transforms.
+ *
+ * - Stable names (`$timeoutId`): Readable AND deterministic across versions
+ * - Readable names (`timeoutId`): Semantic but order-dependent
+ */
+import type { Scope } from "@babel/traverse";
+/**
+ * Returns true if the name has been stable-renamed (starts with $).
+ * Transforms should skip variables with this prefix.
+ */
+export declare const isStableRenamed: (name: string) => boolean;
+/**
+ * Entry for a planned rename operation.
+ */
+type RenameEntry = {
+    /** The Babel scope containing the binding */
+    scope: Scope;
+    /** Current name of the variable */
+    currentName: string;
+    /** Desired semantic base name (e.g., "timeoutId", "error") */
+    baseName: string;
+};
+/**
+ * Collects rename operations and applies them with automatic stability logic.
+ *
+ * Usage:
+ * ```typescript
+ * const group = new RenameGroup();
+ *
+ * // Collect renames during traversal
+ * group.add({ scope: path.scope, currentName: "a", baseName: "timeoutId" });
+ * group.add({ scope: path.scope, currentName: "b", baseName: "timeoutId" });
+ *
+ * // Apply with automatic stability
+ * const count = group.apply();
+ * // Result: a → timeoutId, b → timeoutId2 (readable, 2+ unstable)
+ * // Or if only one: a → $timeoutId (stable, exactly 1 unstable)
+ * ```
+ *
+ * Stability rules (per scope, per baseName):
+ * - If exactly 1 unstable variable wants this name → stable (`$baseName`)
+ * - If 2+ unstable variables want the same name → readable only (`baseName`, `baseName2`, ...)
+ */
+export declare class RenameGroup {
+    private entries;
+    /**
+     * Add a variable to be renamed.
+     * Already-stable names (starting with $) are automatically skipped.
+     */
+    add(entry: RenameEntry): void;
+    /**
+     * Apply all collected renames with automatic stability logic.
+     * Returns the number of transformations applied.
+     */
+    apply(): number;
+}
+export {};

package/dist/core/stable-naming.js

@@ -0,0 +1,121 @@
+/**
+ * Helpers for the stable name prefix convention (§5.6-5.9 in workflow.md).
+ *
+ * The `$` prefix signals that a variable has been renamed stably by a transform
+ * and should be skipped by other transforms.
+ *
+ * - Stable names (`$timeoutId`): Readable AND deterministic across versions
+ * - Readable names (`timeoutId`): Semantic but order-dependent
+ */
+const STABLE_PREFIX = "$";
+/**
+ * Returns true if the name has been stable-renamed (starts with $).
+ * Transforms should skip variables with this prefix.
+ */
+export const isStableRenamed = (name) => {
+    return name.startsWith(STABLE_PREFIX);
+};
+/**
+ * Creates a stable name by adding the $ prefix.
+ * Internal helper - prefer using RenameGroup which handles stability logic automatically.
+ */
+const makeStableName = (baseName) => {
+    return `${STABLE_PREFIX}${baseName}`;
+};
+/**
+ * Finds the next available name slot in a scope.
+ */
+const findAvailableName = (scope, baseName, startIndex, canBeStable) => {
+    let index = startIndex;
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    while (true) {
+        const suffix = index === 1 ? "" : String(index);
+        const candidateBase = `${baseName}${suffix}`;
+        const candidateStable = makeStableName(candidateBase);
+        const candidateReadable = candidateBase;
+        // Check if either form is already taken in this scope
+        const stableTaken = scope.hasBinding(candidateStable);
+        const readableTaken = scope.hasBinding(candidateReadable);
+        if (!stableTaken && !readableTaken) {
+            // This slot is available
+            const name = canBeStable ? candidateStable : candidateReadable;
+            return { name, nextIndex: index + 1 };
+        }
+        index++;
+    }
+};
+/**
+ * Collects rename operations and applies them with automatic stability logic.
+ *
+ * Usage:
+ * ```typescript
+ * const group = new RenameGroup();
+ *
+ * // Collect renames during traversal
+ * group.add({ scope: path.scope, currentName: "a", baseName: "timeoutId" });
+ * group.add({ scope: path.scope, currentName: "b", baseName: "timeoutId" });
+ *
+ * // Apply with automatic stability
+ * const count = group.apply();
+ * // Result: a → timeoutId, b → timeoutId2 (readable, 2+ unstable)
+ * // Or if only one: a → $timeoutId (stable, exactly 1 unstable)
+ * ```
+ *
+ * Stability rules (per scope, per baseName):
+ * - If exactly 1 unstable variable wants this name → stable (`$baseName`)
+ * - If 2+ unstable variables want the same name → readable only (`baseName`, `baseName2`, ...)
+ */
+export class RenameGroup {
+    entries = [];
+    /**
+     * Add a variable to be renamed.
+     * Already-stable names (starting with $) are automatically skipped.
+     */
+    add(entry) {
+        if (isStableRenamed(entry.currentName))
+            return;
+        this.entries.push(entry);
+    }
+    /**
+     * Apply all collected renames with automatic stability logic.
+     * Returns the number of transformations applied.
+     */
+    apply() {
+        // Group entries by (scope, baseName) using a two-level Map
+        const scopeGroups = new Map();
+        for (const entry of this.entries) {
+            let baseNameMap = scopeGroups.get(entry.scope);
+            if (!baseNameMap) {
+                baseNameMap = new Map();
+                scopeGroups.set(entry.scope, baseNameMap);
+            }
+            let group = baseNameMap.get(entry.baseName);
+            if (!group) {
+                group = [];
+                baseNameMap.set(entry.baseName, group);
+            }
+            group.push(entry);
+        }
+        let transformationsApplied = 0;
+        // Process each scope
+        for (const [scope, baseNameMap] of scopeGroups) {
+            // Process each baseName group within this scope
+            for (const [baseName, group] of baseNameMap) {
+                // Determine if names can be stable (only 1 unstable entry for this baseName)
+                const canBeStable = group.length === 1;
+                // Track which index to try next
+                let index = 1;
+                for (const entry of group) {
+                    // Find next available name slot
+                    const targetName = findAvailableName(scope, baseName, index, canBeStable);
+                    index = targetName.nextIndex;
+                    if (entry.currentName !== targetName.name) {
+                        scope.rename(entry.currentName, targetName.name);
+                        transformationsApplied++;
+                    }
+                }
+            }
+        }
+        return transformationsApplied;
+    }
+}

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

@@ -1,6 +1,7 @@
 import * as fs from "node:fs/promises";
 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) => {
@@ -24,6 +25,7 @@ export const checkExpectedEvaluations = async (options) => {
         testCasesDirectory,
         transformIds,
         transformRegistry,
+        recommendedTransformIds: transformPresets.recommended,
     });
     const allPresent = missingManifestEntries.length === 0 && snapshotIssues.length === 0;
     return {

package/dist/scripts/evaluate/check-recommended-snapshot.d.ts

@@ -0,0 +1,11 @@
+import type { Transform } from "../../core/types.js";
+import type { SnapshotIssue } from "./check-snapshots.js";
+type CheckRecommendedSnapshotOptions = {
+    basePath: string;
+    baseContent: string;
+    snapshotPath: string;
+    testCaseName: string;
+    transforms: Transform[];
+};
+export declare const checkRecommendedSnapshot: (options: CheckRecommendedSnapshotOptions) => Promise<SnapshotIssue | undefined>;
+export {};

package/dist/scripts/evaluate/check-recommended-snapshot.js

@@ -0,0 +1,53 @@
+import * as fs from "node:fs/promises";
+import * as prettier from "prettier";
+import { transformContentWithMultiple } from "./transform-content.js";
+const formatCode = async (code) => {
+    return prettier.format(code, { parser: "babel" });
+};
+const fileExists = async (filePath) => {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+export const checkRecommendedSnapshot = async (options) => {
+    const { basePath, baseContent, snapshotPath, testCaseName, transforms } = options;
+    const snapshotExists = await fileExists(snapshotPath);
+    // Run all recommended transforms to get the output
+    const result = await transformContentWithMultiple({
+        content: baseContent,
+        filePath: basePath,
+        transforms,
+    });
+    if (!result.ok) {
+        // Transform failed, skip this check
+        return undefined;
+    }
+    const formattedOutput = await formatCode(result.output);
+    if (snapshotExists) {
+        const snapshotContent = await fs.readFile(snapshotPath, "utf8");
+        const formattedSnapshot = await formatCode(snapshotContent);
+        // Check if snapshot is outdated (recommended snapshots are never "unnecessary")
+        if (formattedOutput !== formattedSnapshot) {
+            return {
+                transformId: "recommended",
+                testCase: testCaseName,
+                snapshotPath,
+                issue: "outdated",
+            };
+        }
+    }
+    else {
+        // Snapshot doesn't exist - it's always required for recommended
+        return {
+            transformId: "recommended",
+            testCase: testCaseName,
+            snapshotPath,
+            issue: "missing-required",
+        };
+    }
+    return undefined;
+};

package/dist/scripts/evaluate/check-snapshots.d.ts

@@ -9,6 +9,7 @@ type CheckAllSnapshotsOptions = {
     testCasesDirectory: string;
     transformIds: string[];
     transformRegistry: Record<string, Transform>;
+    recommendedTransformIds: string[];
 };
 export declare const checkAllSnapshots: (options: CheckAllSnapshotsOptions) => Promise<SnapshotIssue[]>;
 export {};

package/dist/scripts/evaluate/check-snapshots.js

@@ -1,7 +1,9 @@
 import * as fs from "node:fs/promises";
 import path from "node:path";
 import * as prettier from "prettier";
+import { normalizeCode } from "../../core/normalize-code.js";
 import { transformContent } from "./transform-content.js";
+import { checkRecommendedSnapshot } from "./check-recommended-snapshot.js";
 const formatCode = async (code) => {
     return prettier.format(code, { parser: "babel" });
 };
@@ -84,13 +86,18 @@ const getTestCaseNames = async (testCasesDirectory) => {
     return testCaseNames.toSorted();
 };
 export const checkAllSnapshots = async (options) => {
-    const { testCasesDirectory, transformIds, transformRegistry } = options;
+    const { testCasesDirectory, transformIds, transformRegistry, recommendedTransformIds, } = options;
     const snapshotIssues = [];
     const testCaseNames = await getTestCaseNames(testCasesDirectory);
+    // Get the recommended transforms in order
+    const recommendedTransforms = recommendedTransformIds
+        .map((id) => transformRegistry[id])
+        .filter((t) => t !== undefined);
     for (const testCaseName of testCaseNames) {
         const basePath = path.join(testCasesDirectory, testCaseName, "base.js");
         const baseContent = await fs.readFile(basePath, "utf8");
-        const formattedBase = await formatCode(baseContent);
+        const formattedBase = await normalizeCode(baseContent);
+        // Check individual transform snapshots
         for (const transformId of transformIds) {
             const snapshotPath = path.join(testCasesDirectory, testCaseName, `${transformId}.js`);
             const issue = await checkSnapshot({
@@ -106,6 +113,18 @@ export const checkAllSnapshots = async (options) => {
                 snapshotIssues.push(issue);
             }
         }
+        // Check recommended snapshot (always required)
+        const recommendedSnapshotPath = path.join(testCasesDirectory, testCaseName, "recommended.js");
+        const recommendedIssue = await checkRecommendedSnapshot({
+            basePath,
+            baseContent,
+            snapshotPath: recommendedSnapshotPath,
+            testCaseName,
+            transforms: recommendedTransforms,
+        });
+        if (recommendedIssue) {
+            snapshotIssues.push(recommendedIssue);
+        }
     }
     return snapshotIssues;
 };

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

@@ -11,4 +11,9 @@ export declare const transformContent: (options: {
     filePath: string;
     transform: Transform;
 }) => Promise<TransformContentResult>;
+export declare const transformContentWithMultiple: (options: {
+    content: string;
+    filePath: string;
+    transforms: Transform[];
+}) => Promise<TransformContentResult>;
 export {};

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

@@ -2,24 +2,34 @@ import { buildProjectGraph } from "../../core/project-graph.js";
 import { generateCode } from "../../cli/generate-code.js";
 export const transformContent = async (options) => {
     const { content, filePath, transform } = options;
+    return transformContentWithMultiple({
+        content,
+        filePath,
+        transforms: [transform],
+    });
+};
+export const transformContentWithMultiple = async (options) => {
+    const { content, filePath, transforms } = options;
     const projectGraph = buildProjectGraph([{ path: filePath, content }]);
     const file = projectGraph.files.get(filePath);
     if (!file) {
         return { ok: false, error: "Failed to parse input" };
     }
-    try {
-        await transform.transform({
-            projectGraph,
-            currentFile: undefined,
-            options: {},
-        });
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return {
-            ok: false,
-            error: `Transform '${transform.id}' failed: ${message}`,
-        };
+    for (const transform of transforms) {
+        try {
+            await transform.transform({
+                projectGraph,
+                currentFile: undefined,
+                options: {},
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                ok: false,
+                error: `Transform '${transform.id}' failed: ${message}`,
+            };
+        }
     }
     const generated = generateCode(file.ast);
     const output = generated === ""

package/dist/scripts/snapshot/create-snapshot-command.d.ts

@@ -0,0 +1,9 @@
+import { Command } from "@commander-js/extra-typings";
+export type SnapshotCliRawOptions = {
+    testcase: string;
+    transform: string;
+    expected: boolean;
+};
+export declare const createSnapshotCommand: (options: {
+    version: string;
+}) => Command;

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

@@ -0,0 +1,32 @@
+import { Command } from "@commander-js/extra-typings";
+export const createSnapshotCommand = (options) => {
+    const program = new Command()
+        .name("miniread-snapshot")
+        .description("Generate test case snapshots for transform development workflow.")
+        .version(options.version)
+        .showHelpAfterError("(add --help for additional information)")
+        .showSuggestionAfterError()
+        .requiredOption("--testcase <name>", "Test case directory name (e.g., boolean-literals)")
+        .requiredOption("--transform <id>", "Transform ID to run (e.g., expand-boolean-literals)")
+        .option("--expected", "Write {transform}-expected.js, compare with actual, delete expected on success", false);
+    program.addHelpText("after", `
+Examples:
+  # Generate actual snapshot only (for updating existing snapshots)
+  pnpm run snapshot -- --testcase boolean-literals --transform expand-boolean-literals
+
+  # Full expected-file workflow (Design → Test phase)
+  pnpm run snapshot -- --testcase boolean-literals --transform expand-boolean-literals --expected
+    1. Writes {transform}-expected.js (copy of base.js for manual editing)
+    2. Writes {transform}.js (actual transform output)
+    3. Runs diff between expected and actual
+    4. Deletes expected.js on success (no diff)
+
+Workflow:
+  1. Create test-cases/{testcase}/base.js with your minified snippet
+  2. Run with --expected to generate the expected file template
+  3. Manually edit {transform}-expected.js to match your intent
+  4. Re-run with --expected to compare actual output
+  5. On success (no diff), expected file is auto-deleted
+`);
+    return program;
+};

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

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

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

@@ -0,0 +1,162 @@
+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 { 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;
+};
+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`);
+            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.`);
+        return 1;
+    }
+    const expectedPath = path.join(testCaseDirectory, `${transform}-expected.js`);
+    const actualPath = path.join(testCaseDirectory, `${transform}.js`);
+    // Run the transform and format
+    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;
+    }
+    if (expected) {
+        // Expected-file workflow
+        // Step 1: Check if expected file exists, create from base.js if not
+        let expectedExists = false;
+        try {
+            await fs.access(expectedPath);
+            expectedExists = true;
+        }
+        catch {
+            // Expected file doesn't exist, create it from base.js
+            const baseContent = await fs.readFile(basePath, "utf8");
+            const formattedBase = await formatCode(baseContent);
+            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.");
+        }
+        // Step 2: Write actual output
+        await fs.writeFile(actualPath, actualOutput);
+        console.log(`Created: test-cases/${testcase}/${transform}.js`);
+        if (!expectedExists) {
+            // First run - just created expected file, user needs to edit it
+            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;
+        }
+        else {
+            // 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}`);
+                    }
+                }
+            }
+            if (!hasDiff) {
+                // Shouldn't happen since we already checked equality, but just in case
+                console.log("(no visible differences)");
+            }
+            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;
+        }
+    }
+    else {
+        // Simple mode: just write actual output
+        await fs.writeFile(actualPath, actualOutput);
+        console.log(`Created: test-cases/${testcase}/${transform}.js`);
+        return 0;
+    }
+};

package/dist/scripts/snapshot.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};