pareto-test 0.0.1

package/dist/generated/interface/schemas/legacy_json_schema/unmarshall.d.ts

@@ -0,0 +1,303 @@
+import * as _i_in from "../../core/astn_source";
+import * as _i_out from "./data_types/target";
+import * as _i_vd from "./value_deserializers";
+export type _T_Array_Definition = ($$_: _i_in._T_Value, $$_p: {
+    readonly 'value deserializers': _i_vd._T_Value_Deserializers;
+}) => _i_out._T_Array_Definition;
+export type _T_Boolean_Definition = ($$_: _i_in._T_Value, $$_p: {
+    readonly 'value deserializers': _i_vd._T_Value_Deserializers;
+}) => _i_out._T_Boolean_Definition;
+export type _T_Definition = ($$_: _i_in._T_Value, $$_p: {
+    readonly 'value deserializers': _i_vd._T_Value_Deserializers;
+}) => _i_out._T_Definition;
+export type _T_Error = ($$_: _i_in._T_Value, $$_p: {
+    readonly 'value deserializers': _i_vd._T_Value_Deserializers;
+}) => _i_out._T_Error;
+export type _T_Null_Definition = ($$_: _i_in._T_Value, $$_p: {
+    readonly 'value deserializers': _i_vd._T_Value_Deserializers;
+}) => _i_out._T_Null_Definition;
+export type _T_Number_Definition = ($$_: _i_in._T_Value, $$_p: {
+    readonly 'value deserializers': _i_vd._T_Value_Deserializers;
+}) => _i_out._T_Number_Definition;
+export type _T_Object_Definition = ($$_: _i_in._T_Value, $$_p: {
+    readonly 'value deserializers': _i_vd._T_Value_Deserializers;
+}) => _i_out._T_Object_Definition;
+export type _T_Schema = ($$_: _i_in._T_Value, $$_p: {
+    readonly 'value deserializers': _i_vd._T_Value_Deserializers;
+}) => _i_out._T_Schema;
+export type _T_String_Definition = ($$_: _i_in._T_Value, $$_p: {
+    readonly 'value deserializers': _i_vd._T_Value_Deserializers;
+}) => _i_out._T_String_Definition;
+export type _T_Value_Type = ($$_: _i_in._T_Value, $$_p: {
+    readonly 'value deserializers': _i_vd._T_Value_Deserializers;
+}) => _i_out._T_Value_Type;
+export type Array_Definition = _T_Array_Definition;
+export type Boolean_Definition = _T_Boolean_Definition;
+export type Definition = _T_Definition;
+export type Error = _T_Error;
+export type Null_Definition = _T_Null_Definition;
+export type Number_Definition = _T_Number_Definition;
+export type Object_Definition = _T_Object_Definition;
+export type Schema = _T_Schema;
+export type String_Definition = _T_String_Definition;
+export type Value_Type = _T_Value_Type;
+export declare namespace _T_Array_Definition {
+    namespace CONTEXT {
+    }
+    type CONTEXT = _i_in._T_Value;
+    namespace PARAMS {
+        namespace value_deserializers {
+        }
+        type value_deserializers = _i_vd._T_Value_Deserializers;
+    }
+    namespace RESULT {
+    }
+    type RESULT = _i_out._T_Array_Definition;
+}
+export declare namespace _T_Boolean_Definition {
+    namespace CONTEXT {
+    }
+    type CONTEXT = _i_in._T_Value;
+    namespace PARAMS {
+        namespace value_deserializers {
+        }
+        type value_deserializers = _i_vd._T_Value_Deserializers;
+    }
+    namespace RESULT {
+    }
+    type RESULT = _i_out._T_Boolean_Definition;
+}
+export declare namespace _T_Definition {
+    namespace CONTEXT {
+    }
+    type CONTEXT = _i_in._T_Value;
+    namespace PARAMS {
+        namespace value_deserializers {
+        }
+        type value_deserializers = _i_vd._T_Value_Deserializers;
+    }
+    namespace RESULT {
+    }
+    type RESULT = _i_out._T_Definition;
+}
+export declare namespace _T_Error {
+    namespace CONTEXT {
+    }
+    type CONTEXT = _i_in._T_Value;
+    namespace PARAMS {
+        namespace value_deserializers {
+        }
+        type value_deserializers = _i_vd._T_Value_Deserializers;
+    }
+    namespace RESULT {
+    }
+    type RESULT = _i_out._T_Error;
+}
+export declare namespace _T_Null_Definition {
+    namespace CONTEXT {
+    }
+    type CONTEXT = _i_in._T_Value;
+    namespace PARAMS {
+        namespace value_deserializers {
+        }
+        type value_deserializers = _i_vd._T_Value_Deserializers;
+    }
+    namespace RESULT {
+    }
+    type RESULT = _i_out._T_Null_Definition;
+}
+export declare namespace _T_Number_Definition {
+    namespace CONTEXT {
+    }
+    type CONTEXT = _i_in._T_Value;
+    namespace PARAMS {
+        namespace value_deserializers {
+        }
+        type value_deserializers = _i_vd._T_Value_Deserializers;
+    }
+    namespace RESULT {
+    }
+    type RESULT = _i_out._T_Number_Definition;
+}
+export declare namespace _T_Object_Definition {
+    namespace CONTEXT {
+    }
+    type CONTEXT = _i_in._T_Value;
+    namespace PARAMS {
+        namespace value_deserializers {
+        }
+        type value_deserializers = _i_vd._T_Value_Deserializers;
+    }
+    namespace RESULT {
+    }
+    type RESULT = _i_out._T_Object_Definition;
+}
+export declare namespace _T_Schema {
+    namespace CONTEXT {
+    }
+    type CONTEXT = _i_in._T_Value;
+    namespace PARAMS {
+        namespace value_deserializers {
+        }
+        type value_deserializers = _i_vd._T_Value_Deserializers;
+    }
+    namespace RESULT {
+    }
+    type RESULT = _i_out._T_Schema;
+}
+export declare namespace _T_String_Definition {
+    namespace CONTEXT {
+    }
+    type CONTEXT = _i_in._T_Value;
+    namespace PARAMS {
+        namespace value_deserializers {
+        }
+        type value_deserializers = _i_vd._T_Value_Deserializers;
+    }
+    namespace RESULT {
+    }
+    type RESULT = _i_out._T_String_Definition;
+}
+export declare namespace _T_Value_Type {
+    namespace CONTEXT {
+    }
+    type CONTEXT = _i_in._T_Value;
+    namespace PARAMS {
+        namespace value_deserializers {
+        }
+        type value_deserializers = _i_vd._T_Value_Deserializers;
+    }
+    namespace RESULT {
+    }
+    type RESULT = _i_out._T_Value_Type;
+}
+export declare namespace Array_Definition {
+    namespace CONTEXT {
+    }
+    type CONTEXT = _i_in._T_Value;
+    namespace PARAMS {
+        namespace value_deserializers {
+        }
+        type value_deserializers = _i_vd._T_Value_Deserializers;
+    }
+    namespace RESULT {
+    }
+    type RESULT = _i_out._T_Array_Definition;
+}
+export declare namespace Boolean_Definition {
+    namespace CONTEXT {
+    }
+    type CONTEXT = _i_in._T_Value;
+    namespace PARAMS {
+        namespace value_deserializers {
+        }
+        type value_deserializers = _i_vd._T_Value_Deserializers;
+    }
+    namespace RESULT {
+    }
+    type RESULT = _i_out._T_Boolean_Definition;
+}
+export declare namespace Definition {
+    namespace CONTEXT {
+    }
+    type CONTEXT = _i_in._T_Value;
+    namespace PARAMS {
+        namespace value_deserializers {
+        }
+        type value_deserializers = _i_vd._T_Value_Deserializers;
+    }
+    namespace RESULT {
+    }
+    type RESULT = _i_out._T_Definition;
+}
+export declare namespace Error {
+    namespace CONTEXT {
+    }
+    type CONTEXT = _i_in._T_Value;
+    namespace PARAMS {
+        namespace value_deserializers {
+        }
+        type value_deserializers = _i_vd._T_Value_Deserializers;
+    }
+    namespace RESULT {
+    }
+    type RESULT = _i_out._T_Error;
+}
+export declare namespace Null_Definition {
+    namespace CONTEXT {
+    }
+    type CONTEXT = _i_in._T_Value;
+    namespace PARAMS {
+        namespace value_deserializers {
+        }
+        type value_deserializers = _i_vd._T_Value_Deserializers;
+    }
+    namespace RESULT {
+    }
+    type RESULT = _i_out._T_Null_Definition;
+}
+export declare namespace Number_Definition {
+    namespace CONTEXT {
+    }
+    type CONTEXT = _i_in._T_Value;
+    namespace PARAMS {
+        namespace value_deserializers {
+        }
+        type value_deserializers = _i_vd._T_Value_Deserializers;
+    }
+    namespace RESULT {
+    }
+    type RESULT = _i_out._T_Number_Definition;
+}
+export declare namespace Object_Definition {
+    namespace CONTEXT {
+    }
+    type CONTEXT = _i_in._T_Value;
+    namespace PARAMS {
+        namespace value_deserializers {
+        }
+        type value_deserializers = _i_vd._T_Value_Deserializers;
+    }
+    namespace RESULT {
+    }
+    type RESULT = _i_out._T_Object_Definition;
+}
+export declare namespace Schema {
+    namespace CONTEXT {
+    }
+    type CONTEXT = _i_in._T_Value;
+    namespace PARAMS {
+        namespace value_deserializers {
+        }
+        type value_deserializers = _i_vd._T_Value_Deserializers;
+    }
+    namespace RESULT {
+    }
+    type RESULT = _i_out._T_Schema;
+}
+export declare namespace String_Definition {
+    namespace CONTEXT {
+    }
+    type CONTEXT = _i_in._T_Value;
+    namespace PARAMS {
+        namespace value_deserializers {
+        }
+        type value_deserializers = _i_vd._T_Value_Deserializers;
+    }
+    namespace RESULT {
+    }
+    type RESULT = _i_out._T_String_Definition;
+}
+export declare namespace Value_Type {
+    namespace CONTEXT {
+    }
+    type CONTEXT = _i_in._T_Value;
+    namespace PARAMS {
+        namespace value_deserializers {
+        }
+        type value_deserializers = _i_vd._T_Value_Deserializers;
+    }
+    namespace RESULT {
+    }
+    type RESULT = _i_out._T_Value_Type;
+}

package/dist/generated/interface/schemas/legacy_json_schema/unmarshall.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidW5tYXJzaGFsbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9nZW5lcmF0ZWQvaW50ZXJmYWNlL3NjaGVtYXMvbGVnYWN5X2pzb25fc2NoZW1hL3VubWFyc2hhbGwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist/generated/interface/schemas/legacy_json_schema/value_deserializers.d.ts

@@ -0,0 +1,44 @@
+export type _T_Value_Deserializers = {
+    readonly 'boolean': ($$_: string, $$_p: null) => boolean;
+    readonly 'custom numbers': null;
+    readonly 'default number': ($$_: string, $$_p: null) => number;
+};
+export type Value_Deserializers = _T_Value_Deserializers;
+export declare namespace _T_Value_Deserializers {
+    namespace _boolean {
+        type CONTEXT = string;
+        namespace PARAMS {
+        }
+        type RESULT = boolean;
+    }
+    type _boolean = ($$_: string, $$_p: null) => boolean;
+    namespace custom_numbers {
+    }
+    type custom_numbers = null;
+    namespace default_number {
+        type CONTEXT = string;
+        namespace PARAMS {
+        }
+        type RESULT = number;
+    }
+    type default_number = ($$_: string, $$_p: null) => number;
+}
+export declare namespace Value_Deserializers {
+    namespace _boolean {
+        type CONTEXT = string;
+        namespace PARAMS {
+        }
+        type RESULT = boolean;
+    }
+    type _boolean = ($$_: string, $$_p: null) => boolean;
+    namespace custom_numbers {
+    }
+    type custom_numbers = null;
+    namespace default_number {
+        type CONTEXT = string;
+        namespace PARAMS {
+        }
+        type RESULT = number;
+    }
+    type default_number = ($$_: string, $$_p: null) => number;
+}

package/dist/generated/interface/schemas/legacy_json_schema/value_deserializers.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsdWVfZGVzZXJpYWxpemVycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9nZW5lcmF0ZWQvaW50ZXJmYWNlL3NjaGVtYXMvbGVnYWN5X2pzb25fc2NoZW1hL3ZhbHVlX2Rlc2VyaWFsaXplcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist/generated/interface/schemas/legacy_json_schema/value_serializers.d.ts

@@ -0,0 +1,44 @@
+export type _T_Value_Serializers = {
+    readonly 'boolean': ($$_: boolean, $$_p: null) => string;
+    readonly 'custom numbers': null;
+    readonly 'default number': ($$_: number, $$_p: null) => string;
+};
+export type Value_Serializers = _T_Value_Serializers;
+export declare namespace _T_Value_Serializers {
+    namespace _boolean {
+        type CONTEXT = boolean;
+        namespace PARAMS {
+        }
+        type RESULT = string;
+    }
+    type _boolean = ($$_: boolean, $$_p: null) => string;
+    namespace custom_numbers {
+    }
+    type custom_numbers = null;
+    namespace default_number {
+        type CONTEXT = number;
+        namespace PARAMS {
+        }
+        type RESULT = string;
+    }
+    type default_number = ($$_: number, $$_p: null) => string;
+}
+export declare namespace Value_Serializers {
+    namespace _boolean {
+        type CONTEXT = boolean;
+        namespace PARAMS {
+        }
+        type RESULT = string;
+    }
+    type _boolean = ($$_: boolean, $$_p: null) => string;
+    namespace custom_numbers {
+    }
+    type custom_numbers = null;
+    namespace default_number {
+        type CONTEXT = number;
+        namespace PARAMS {
+        }
+        type RESULT = string;
+    }
+    type default_number = ($$_: number, $$_p: null) => string;
+}

package/dist/generated/interface/schemas/legacy_json_schema/value_serializers.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsdWVfc2VyaWFsaXplcnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvZ2VuZXJhdGVkL2ludGVyZmFjZS9zY2hlbWFzL2xlZ2FjeV9qc29uX3NjaGVtYS92YWx1ZV9zZXJpYWxpemVycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/dist/interface/testrunner.d.ts

@@ -0,0 +1,4 @@
+export type TestRunner = {
+    'target_extension': string;
+    'transformer': (input_content: string, filename_without_extension: string) => string;
+};

package/dist/interface/testrunner.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVzdHJ1bm5lci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9pbnRlcmZhY2UvdGVzdHJ1bm5lci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/dist/run_tests.d.ts

@@ -0,0 +1,4 @@
+import * as _et from 'exupery-core-types';
+import { TestRunner } from "./interface/testrunner";
+export declare const run_tests: (tests: _et.Dictionary<TestRunner>) => void;
+export declare const test_runner: ($p: TestRunner, name: string, overwrite_expected: boolean) => boolean;

package/dist/run_tests.js

@@ -0,0 +1,239 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.test_runner = exports.run_tests = void 0;
+const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const run_tests = (tests) => {
+    const test_base_dir = '/home/corno/workspace/pareto-development-tools/test';
+    const data_dir = '/home/corno/workspace/pareto-development-tools/data/test';
+    const args = process.argv.slice(2);
+    const overwrite_expected = args.includes('--overwrite-expected');
+    const specific_test = args.find(arg => arg.startsWith('--test='))?.split('=')[1];
+    // Clean the entire 'actual' directory before starting tests
+    const actual_dir = path.join(data_dir, 'actual');
+    if (fs.existsSync(actual_dir)) {
+        // Remove all contents
+        const entries = fs.readdirSync(actual_dir);
+        for (const entry of entries) {
+            const entry_path = path.join(actual_dir, entry);
+            const stat = fs.statSync(entry_path);
+            if (stat.isDirectory()) {
+                fs.rmSync(entry_path, { recursive: true, force: true });
+            }
+            else {
+                fs.unlinkSync(entry_path);
+            }
+        }
+        console.log('✓ Cleaned actual directory\n');
+    }
+    else {
+        fs.mkdirSync(actual_dir, { recursive: true });
+        console.log('✓ Created actual directory\n');
+    }
+    console.log('Running all tests...\n');
+    console.log('-'.repeat(60));
+    let failed_tests = 0;
+    let passed_tests = 0;
+    const failed_test_types = [];
+    // Run each test
+    tests.map(($, key) => {
+        try {
+            const success = (0, exports.test_runner)($, key, overwrite_expected);
+            if (success) {
+                passed_tests++;
+            }
+            else {
+                failed_tests++;
+                failed_test_types.push(key);
+            }
+        }
+        catch (err) {
+            failed_tests++;
+            failed_test_types.push(key);
+        }
+    });
+    // Summary
+    console.log('\n' + '-'.repeat(60));
+    console.log(`Test Summary:`);
+    console.log(`  - ${passed_tests} test(s) passed`);
+    console.log(`  - ${failed_tests} test(s) failed`);
+    if (failed_tests > 0) {
+        console.log('\n❌ Some tests failed');
+        // Open Beyond Compare for expected vs actual directories
+        const expected_path = path.join(data_dir, 'expected');
+        const actual_path = path.join(data_dir, 'actual');
+        console.log(`\nOpening Beyond Compare...`);
+        console.log(`  Expected: ${expected_path}`);
+        console.log(`  Actual:   ${actual_path}`);
+        try {
+            (0, child_process_1.execSync)(`bcompare "${expected_path}" "${actual_path}" &`, {
+                stdio: 'ignore'
+            });
+        }
+        catch (err) {
+            console.error(`  ⚠️  Could not open Beyond Compare. Make sure 'bcompare' is in your PATH.`);
+        }
+        process.exit(1);
+    }
+    else {
+        console.log('\n✓ All tests passed');
+    }
+};
+exports.run_tests = run_tests;
+function to_snake_case(str) {
+    return str.toLowerCase().replace(/\s+/g, '_');
+}
+const test_runner = ($p, name, overwrite_expected) => {
+    const data_dir = path.join(__dirname, '../../../data');
+    const test_data_dir = path.join(data_dir, 'test');
+    const fixtures_dir = path.join(test_data_dir, 'fixtures');
+    const test_dir_name = to_snake_case(name);
+    const input_dir = path.join(fixtures_dir, test_dir_name);
+    const expected_dir = path.join(test_data_dir, 'expected');
+    const actual_dir = path.join(test_data_dir, 'actual');
+    console.log('='.repeat(60));
+    console.log(`Running test: ${name}\n`);
+    // Check if input directory exists
+    if (!fs.existsSync(input_dir)) {
+        console.error(`❌ Input directory not found: ${input_dir}`);
+        return false;
+    }
+    // Ensure actual output directory exists
+    const actual_output_dir = path.join(actual_dir, test_dir_name);
+    if (!fs.existsSync(actual_output_dir)) {
+        fs.mkdirSync(actual_output_dir, { recursive: true });
+    }
+    // Clear/create expected output directory if overwrite flag is set
+    const expected_output_dir = path.join(expected_dir, test_dir_name);
+    if (overwrite_expected) {
+        // Only clear if the directory exists and has files
+        if (fs.existsSync(expected_output_dir)) {
+            const files = fs.readdirSync(expected_output_dir);
+            console.log(`⚠️  Overwrite mode: Will replace ${files.length} existing expected file(s) in ${test_dir_name}`);
+            for (const file of files) {
+                fs.unlinkSync(path.join(expected_output_dir, file));
+            }
+            console.log(`✓ Cleared ${expected_output_dir}`);
+        }
+        else {
+            fs.mkdirSync(expected_output_dir, { recursive: true });
+            console.log(`✓ Created ${expected_output_dir}`);
+        }
+    }
+    else {
+        // Ensure expected output directory exists
+        if (!fs.existsSync(expected_output_dir)) {
+            fs.mkdirSync(expected_output_dir, { recursive: true });
+        }
+    }
+    // Read all files from input directory
+    const input_files = fs.readdirSync(input_dir);
+    console.log(`\nFound ${input_files.length} input file(s) to process\n`);
+    let differences_found = 0;
+    let matches_found = 0;
+    for (const input_file of input_files) {
+        const base_name = path.basename(input_file, path.extname(input_file));
+        const output_name = `${base_name}.${$p.target_extension}`;
+        try {
+            // Read input file
+            const input_path = path.join(input_dir, input_file);
+            const input_content = fs.readFileSync(input_path, 'utf8');
+            // Transform input to output
+            const output_content = $p.transformer(input_content, base_name);
+            // If overwrite expected, write to expected directory
+            if (overwrite_expected) {
+                const expected_path = path.join(expected_output_dir, output_name);
+                fs.writeFileSync(expected_path, output_content);
+                console.log(`\x1b[32m${base_name} ✓\x1b[0m`);
+            }
+            else {
+                // Compare with expected
+                const expected_path = path.join(expected_output_dir, output_name);
+                if (!fs.existsSync(expected_path)) {
+                    // No expected file exists, write to actual
+                    const actual_path = path.join(actual_output_dir, output_name);
+                    fs.writeFileSync(actual_path, output_content);
+                    console.log(`\x1b[31m${base_name} ❌\x1b[0m`);
+                    differences_found++;
+                }
+                else {
+                    // Compare with expected
+                    const expected_content = fs.readFileSync(expected_path, 'utf8');
+                    if (output_content === expected_content) {
+                        console.log(`\x1b[32m${base_name} ✓\x1b[0m`);
+                        matches_found++;
+                    }
+                    else {
+                        // Write to actual directory
+                        const actual_path = path.join(actual_output_dir, output_name);
+                        fs.writeFileSync(actual_path, output_content);
+                        console.log(`\x1b[31m${base_name} ❌\x1b[0m`);
+                        differences_found++;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // Write error information to actual file so we can see what went wrong
+            const actual_path = path.join(actual_output_dir, output_name);
+            const error_content = `ERROR during transformation:\n${error instanceof Error ? error.stack : String(error)}`;
+            fs.writeFileSync(actual_path, error_content);
+            console.log(`\x1b[31m${base_name} ❌\x1b[0m`);
+            console.log('\n' + '-'.repeat(60));
+            console.error(`❌ FATAL ERROR during transformation of ${base_name}:`);
+            console.error(error instanceof Error ? error.message : String(error));
+            console.error(`Full error details written to: ${actual_path}`);
+            console.error(`\nAborting test run due to transformation error.`);
+            console.log('='.repeat(60));
+            process.exit(1);
+        }
+    }
+    console.log('\n' + '-'.repeat(60));
+    if (overwrite_expected) {
+        console.log(`✓ Baseline set: ${input_files.length} file(s) written to expected directory`);
+        console.log('='.repeat(60));
+        return true;
+    }
+    else {
+        console.log(`Summary:`);
+        console.log(`  - ${matches_found} file(s) match expected`);
+        console.log(`  - ${differences_found} file(s) differ or missing expected`);
+        if (differences_found > 0) {
+            console.log(`\n⚠️  Differences found! Check files in: ${actual_output_dir}`);
+            console.log(`To set new baseline, run with: --overwrite-expected`);
+            console.log('='.repeat(60));
+            return false;
+        }
+        else {
+            console.log(`\n✓ All generated files match expected`);
+            console.log('='.repeat(60));
+            return true;
+        }
+    }
+};
+exports.test_runner = test_runner;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"run_tests.js","sourceRoot":"","sources":["../src/run_tests.ts"],"names":[],"mappings":"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"}