mediaguru 1.0.0

package/dist/index.js

@@ -0,0 +1,429 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import fs from 'fs';
+import path from 'path';
+import { printHeader, printFooter } from './utils/branding.js';
+import { launchInteractive } from './cli/interactive.js';
+import { PdfEngine } from './core/pdf/index.js';
+import { ImageEngine } from './core/image/index.js';
+import { QrEngine } from './core/qr/index.js';
+import { OcrEngine } from './core/ocr/index.js';
+import { ScreenshotEngine } from './core/screenshot/index.js';
+import { Text2ImgEngine } from './core/text2img/index.js';
+import { CompressEngine } from './core/compress/index.js';
+import { BatchEngine } from './core/batch/index.js';
+import { ExportEngine } from './core/export/index.js';
+import { ConfigManager } from './core/config/index.js';
+import { PluginRegistry } from './plugins/index.js';
+import { formatBytes } from './utils/file.js';
+import { RestApiServer } from './core/server/index.js';
+const program = new Command();
+program
+    .name('mediaguru')
+    .description('MediaGuru CLI — Universal Document & Media Processing Toolkit')
+    .version('1.0.0');
+// Trigger beforeCommand hooks
+program.hook('preAction', async (thisCommand, actionCommand) => {
+    await PluginRegistry.triggerBeforeCommand(actionCommand.name(), actionCommand.args);
+});
+// Trigger afterCommand hooks and footer
+program.hook('postAction', async (thisCommand, actionCommand) => {
+    await PluginRegistry.triggerAfterCommand(actionCommand.name(), actionCommand.args);
+    printFooter();
+});
+// PDF Command group
+const pdf = program.command('pdf').description('PDF manipulation operations');
+pdf
+    .command('merge')
+    .description('Merge multiple PDFs into a single file')
+    .argument('<files...>', 'Paths to PDF files')
+    .action(async (files) => {
+    const spinner = ora('Merging PDF documents...').start();
+    try {
+        const out = await PdfEngine.merge(files);
+        spinner.succeed(`PDF files merged successfully to: ${chalk.cyan(out)}`);
+    }
+    catch (e) {
+        spinner.fail(`Merge failed: ${e.message}`);
+    }
+});
+pdf
+    .command('split')
+    .description('Split PDF into individual pages')
+    .argument('<file>', 'Path to PDF file')
+    .action(async (file) => {
+    const spinner = ora('Splitting PDF pages...').start();
+    try {
+        const pages = await PdfEngine.split(file);
+        spinner.succeed(`PDF split complete. Extracted ${pages.length} pages:`);
+        pages.forEach(p => console.log(`  - ${chalk.cyan(p)}`));
+    }
+    catch (e) {
+        spinner.fail(`Split failed: ${e.message}`);
+    }
+});
+pdf
+    .command('extract')
+    .description('Extract plain text from PDF')
+    .argument('<file>', 'Path to PDF file')
+    .action(async (file) => {
+    const spinner = ora('Extracting text from PDF...').start();
+    try {
+        const text = await PdfEngine.extractText(file);
+        spinner.succeed('Extraction completed. Text content:');
+        console.log(chalk.dim('\n' + '─'.repeat(40)));
+        console.log(text.trim());
+        console.log(chalk.dim('─'.repeat(40)));
+    }
+    catch (e) {
+        spinner.fail(`Extraction failed: ${e.message}`);
+    }
+});
+pdf
+    .command('compress')
+    .description('Optimize and compress PDF document size')
+    .argument('<file>', 'Path to PDF file')
+    .action(async (file) => {
+    const spinner = ora('Compressing PDF stream...').start();
+    try {
+        const out = await PdfEngine.compress(file);
+        spinner.succeed(`PDF optimized and saved: ${chalk.cyan(out)}`);
+    }
+    catch (e) {
+        spinner.fail(`Compression failed: ${e.message}`);
+    }
+});
+// Root level pdf default actions (markdown/HTML compile)
+pdf
+    .argument('<file>', 'Markdown (.md) or HTML (.html) source document')
+    .action(async (file) => {
+    const ext = path.extname(file).toLowerCase();
+    const spinner = ora('Compiling document to PDF...').start();
+    try {
+        let out = '';
+        if (ext === '.md') {
+            out = await PdfEngine.markdownToPdf(file);
+            spinner.succeed(`Markdown compiled: ${chalk.cyan(out)}`);
+        }
+        else if (ext === '.html' || ext === '.htm') {
+            out = await PdfEngine.htmlToPdf(file);
+            spinner.succeed(`HTML compiled: ${chalk.cyan(out)}`);
+        }
+        else {
+            spinner.fail(`Unsupported file type: ${ext}. Please supply .md or .html`);
+        }
+    }
+    catch (e) {
+        spinner.fail(`Compilation failed: ${e.message}`);
+    }
+});
+// Image Command group
+const image = program.command('image').description('Image manipulation operations');
+image
+    .command('resize')
+    .description('Resize image dimensions')
+    .argument('<file>', 'Path to image file')
+    .argument('<size>', 'Resolution dimensions (e.g. 800x600 or 800)')
+    .action(async (file, size) => {
+    const spinner = ora('Resizing image layout...').start();
+    try {
+        const out = await ImageEngine.resize(file, size);
+        spinner.succeed(`Image resized: ${chalk.cyan(out)}`);
+    }
+    catch (e) {
+        spinner.fail(`Resize failed: ${e.message}`);
+    }
+});
+image
+    .command('convert')
+    .description('Convert image format')
+    .argument('<file>', 'Path to image file')
+    .argument('<format>', 'Target format (webp, png, jpg, jpeg)')
+    .action(async (file, format) => {
+    const spinner = ora(`Converting format to ${format}...`).start();
+    try {
+        const out = await ImageEngine.convert(file, format);
+        spinner.succeed(`Image converted: ${chalk.cyan(out)}`);
+    }
+    catch (e) {
+        spinner.fail(`Conversion failed: ${e.message}`);
+    }
+});
+image
+    .command('watermark')
+    .description('Overlay a watermark logo on top of an image')
+    .argument('<file>', 'Path to main image file')
+    .argument('<watermark>', 'Path to watermark logo image')
+    .action(async (file, watermark) => {
+    const spinner = ora('Overlaying watermark composite...').start();
+    try {
+        const out = await ImageEngine.watermark(file, watermark);
+        spinner.succeed(`Watermark composite applied: ${chalk.cyan(out)}`);
+    }
+    catch (e) {
+        spinner.fail(`Watermarking failed: ${e.message}`);
+    }
+});
+image
+    .command('remove-bg')
+    .description('Remove background from image')
+    .argument('<file>', 'Path to image file')
+    .option('--api', 'Force use API background removal engine (requires remove.bg API key)')
+    .action(async (file, options) => {
+    const engineType = options.api ? 'api' : 'local';
+    const spinner = ora(`Removing background (engine: ${engineType})...`).start();
+    try {
+        const out = await ImageEngine.removeBg(file, engineType);
+        spinner.succeed(`Background removed: ${chalk.cyan(out)}`);
+    }
+    catch (e) {
+        spinner.fail(`Background removal failed: ${e.message}`);
+    }
+});
+// QR Generator Command
+program
+    .command('qr')
+    .description('Generate QR Code from text or url')
+    .argument('<text>', 'URL or text to encode')
+    .option('--svg', 'Output SVG vector path')
+    .option('--size <number>', 'Resolution size in px', '300')
+    .action(async (text, options) => {
+    const spinner = ora('Generating QR Code...').start();
+    try {
+        const sizeVal = parseInt(options.size, 10) || 300;
+        const out = await QrEngine.generate(text, { svg: options.svg, size: sizeVal });
+        spinner.succeed(`QR Code saved: ${chalk.cyan(out)}`);
+    }
+    catch (e) {
+        spinner.fail(`Generation failed: ${e.message}`);
+    }
+});
+// OCR Command
+program
+    .command('ocr')
+    .description('Extract text from image (OCR)')
+    .argument('<file>', 'Path to image file')
+    .option('--export <format>', 'Export result to file format (txt, markdown, json)')
+    .action(async (file, options) => {
+    const spinner = ora('Parsing image text (OCR)...').start();
+    try {
+        const exportFormat = options.export ? options.export.toLowerCase() : undefined;
+        const res = await OcrEngine.extract(file, { exportFormat });
+        spinner.succeed('OCR Extraction completed. Result:');
+        console.log(chalk.dim('\n' + '─'.repeat(40)));
+        console.log(res.text.trim());
+        console.log(chalk.dim('─'.repeat(40)));
+        if (res.exportedPath) {
+            console.log(`\nExport file written: ${chalk.cyan(res.exportedPath)}`);
+        }
+    }
+    catch (e) {
+        spinner.fail(`OCR Extraction failed: ${e.message}`);
+    }
+});
+// Website Screenshot Command
+program
+    .command('screenshot')
+    .description('Capture responsive website screenshot')
+    .argument('<url>', 'Webpage URL')
+    .option('--full-page', 'Capture full scroll height')
+    .option('--mobile', 'Emulate high-end mobile layout')
+    .action(async (url, options) => {
+    const spinner = ora('Rendering website screenshot...').start();
+    try {
+        const out = await ScreenshotEngine.capture(url, {
+            fullPage: options.fullPage,
+            mobile: options.mobile,
+        });
+        spinner.succeed(`Website screenshot captured: ${chalk.cyan(out)}`);
+    }
+    catch (e) {
+        spinner.fail(`Screenshot failed: ${e.message}`);
+    }
+});
+// Text-to-Image (Social Card) Command
+program
+    .command('text2img')
+    .description('Generate stylized social announcement cards or banner images')
+    .argument('<text>', 'Card text body')
+    .option('--theme <type>', 'Visual color theme (dark, light, glass)', 'dark')
+    .option('--type <layout>', 'Aspect ratio structure (social, quote, poster, banner)', 'social')
+    .option('--title <string>', 'Optional category/header title')
+    .option('--author <string>', 'Optional author credits')
+    .action(async (text, options) => {
+    const spinner = ora('Rendering custom card template in browser...').start();
+    try {
+        const out = await Text2ImgEngine.generate(text, {
+            theme: options.theme.toLowerCase(),
+            type: options.type.toLowerCase(),
+            title: options.title,
+            author: options.author,
+        });
+        spinner.succeed(`Social graphics card generated: ${chalk.cyan(out)}`);
+    }
+    catch (e) {
+        spinner.fail(`Text2img rendering failed: ${e.message}`);
+    }
+});
+// Compression Command
+program
+    .command('compress')
+    .description('Reduce image file size or entire directories recursively')
+    .argument('<path>', 'File or folder path')
+    .action(async (targetPath) => {
+    const stat = fs.statSync(targetPath);
+    if (stat.isDirectory()) {
+        const spinner = ora('Compressing folder files recursively...').start();
+        try {
+            const results = await CompressEngine.compressFolder(targetPath);
+            spinner.succeed(`Recursive folder compression completed!`);
+            let totalOriginal = 0;
+            let totalCompressed = 0;
+            results.forEach(r => {
+                totalOriginal += r.originalSize;
+                totalCompressed += r.compressedSize;
+            });
+            const totalSaved = totalOriginal - totalCompressed;
+            const totalPct = totalOriginal > 0 ? (totalSaved / totalOriginal) * 100 : 0;
+            console.log(chalk.bold.yellow('\nBatch Compression Statistics:'));
+            console.log(`- Files processed: ${chalk.cyan(results.length)}`);
+            console.log(`- Total original size: ${chalk.bold(formatBytes(totalOriginal))}`);
+            console.log(`- Total compressed size: ${chalk.bold(formatBytes(totalCompressed))}`);
+            console.log(`- Total space saved: ${chalk.green.bold(formatBytes(totalSaved))} (${chalk.green.bold(totalPct.toFixed(1))}% reduction)`);
+        }
+        catch (e) {
+            spinner.fail(`Folder compression failed: ${e.message}`);
+        }
+    }
+    else {
+        const spinner = ora('Optimizing image stream...').start();
+        try {
+            const res = await CompressEngine.compressImage(targetPath);
+            spinner.succeed(`Image file optimized: ${chalk.cyan(res.filePath)}`);
+            console.log(chalk.bold.yellow('\nCompression Statistics:'));
+            console.log(`- Original size: ${chalk.bold(formatBytes(res.originalSize))}`);
+            console.log(`- Compressed size: ${chalk.bold(formatBytes(res.compressedSize))}`);
+            console.log(`- Savings: ${chalk.green.bold(formatBytes(res.savedBytes))} (${chalk.green.bold(res.percentage.toFixed(1))}% reduction)`);
+        }
+        catch (e) {
+            spinner.fail(`Image compression failed: ${e.message}`);
+        }
+    }
+});
+// Batch Command
+program
+    .command('batch')
+    .description('Run operations across groups of matching files')
+    .argument('<pattern>', 'Glob file search pattern (e.g. "images/*.png")')
+    .option('--convert <format>', 'Convert batch to target format (png, jpg, webp)')
+    .option('--pdf', 'Compile batch documents into PDF files')
+    .action(async (pattern, options) => {
+    if (!options.convert && !options.pdf) {
+        console.error(chalk.red('Error: You must specify --convert <format> or --pdf.'));
+        process.exit(1);
+    }
+    const spinner = ora('Executing batch processing jobs...').start();
+    try {
+        let results;
+        if (options.convert) {
+            results = await BatchEngine.convertImages(pattern, options.convert);
+        }
+        else {
+            results = await BatchEngine.convertToPdf(pattern);
+        }
+        const succeeded = results.filter(r => r.success);
+        const failed = results.filter(r => !r.success);
+        spinner.succeed(`Batch operations completed!`);
+        console.log(chalk.bold.yellow('\nBatch Statistics:'));
+        console.log(`- Total tasks: ${chalk.cyan(results.length)}`);
+        console.log(`- Succeeded: ${chalk.green(succeeded.length)}`);
+        console.log(`- Failed: ${chalk.red(failed.length)}`);
+        if (failed.length > 0) {
+            console.log(chalk.bold.red('\nFailures:'));
+            failed.forEach(f => console.log(`  - ${f.sourceFile}: ${chalk.dim(f.error)}`));
+        }
+    }
+    catch (e) {
+        spinner.fail(`Batch processing execution failed: ${e.message}`);
+    }
+});
+// Export Command
+program
+    .command('export')
+    .description('Export configurations or convert JSON datasets to CSV/Markdown')
+    .argument('<format>', 'Target output format (json, markdown, csv)')
+    .option('--source <file>', 'Path to JSON file to convert (optional)')
+    .action(async (format, options) => {
+    const fmt = format.toLowerCase();
+    if (options.source) {
+        const spinner = ora(`Converting JSON file to ${format}...`).start();
+        try {
+            if (fmt === 'json') {
+                spinner.fail('Cannot convert a JSON file into a JSON file.');
+                return;
+            }
+            const out = await ExportEngine.convertJsonData(options.source, fmt);
+            spinner.succeed(`Dataset exported: ${chalk.cyan(out)}`);
+        }
+        catch (e) {
+            spinner.fail(`Conversion failed: ${e.message}`);
+        }
+    }
+    else {
+        const spinner = ora(`Exporting config parameters as ${format}...`).start();
+        try {
+            const out = await ExportEngine.exportConfig(fmt);
+            spinner.succeed(`Settings exported: ${chalk.cyan(out)}`);
+        }
+        catch (e) {
+            spinner.fail(`Export failed: ${e.message}`);
+        }
+    }
+});
+// Config Command
+program
+    .command('config')
+    .description('Print or modify configuration parameters')
+    .action(async () => {
+    const current = ConfigManager.load();
+    console.log(chalk.bold.yellow('\nCurrent MediaGuru Settings:'));
+    console.log(`- Default Image Format: ${chalk.cyan(current.defaultImageFormat)}`);
+    console.log(`- PDF Rendering Engine: ${chalk.cyan(current.pdfEngine)}`);
+    console.log(`- Compression Quality: ${chalk.cyan(current.compressionQuality + '%')}`);
+    console.log(`- Screenshot Resolution: ${chalk.cyan(current.screenshotResolution)}`);
+    console.log(`- Default Output Folder: ${chalk.cyan(current.outputFolder)}`);
+    console.log(chalk.dim('\nTo edit settings, run the CLI without arguments to open interactive mode.'));
+});
+// Standalone REST API Server Command
+program
+    .command('server')
+    .description('Start a local HTTP REST API server')
+    .option('--port <number>', 'Port to listen on', '3000')
+    .action(async (options) => {
+    const port = parseInt(options.port, 10) || 3000;
+    const server = new RestApiServer();
+    const spinner = ora('Starting HTTP REST Server...').start();
+    try {
+        spinner.stop(); // Stop spinner to avoid overlapping text
+        await server.start(port);
+    }
+    catch (e) {
+        spinner.fail(`Server failed to start: ${e.message}`);
+    }
+});
+// Bootstrap CLI
+async function bootstrap() {
+    // Inject plugin custom commands
+    PluginRegistry.injectCustomCommands(program);
+    // If no arguments, launch interactive mode
+    if (process.argv.length <= 2) {
+        await launchInteractive();
+    }
+    else {
+        // Print ASCII art header on direct command invocations
+        printHeader();
+        program.parse(process.argv);
+    }
+}
+bootstrap();

package/dist/plugins/index.d.ts

@@ -0,0 +1,41 @@
+import { Command } from 'commander';
+export interface IMediaGuruPlugin {
+    name: string;
+    version: string;
+    description?: string;
+    /**
+     * Executed before any built-in command runs.
+     */
+    beforeCommand?(commandName: string, args: any[]): Promise<void>;
+    /**
+     * Executed after any built-in command runs successfully.
+     */
+    afterCommand?(commandName: string, result: any): Promise<void>;
+    /**
+     * Allows the plugin to inject brand new subcommands into Commander.js!
+     */
+    registerCustomCommands?(program: Command): void;
+}
+export declare class PluginRegistry {
+    private static plugins;
+    /**
+     * Registers a plugin instance.
+     */
+    static registerPlugin(plugin: IMediaGuruPlugin): void;
+    /**
+     * Retrieves all loaded plugins.
+     */
+    static getPlugins(): IMediaGuruPlugin[];
+    /**
+     * Lifecycle trigger: before command execution.
+     */
+    static triggerBeforeCommand(commandName: string, args: any[]): Promise<void>;
+    /**
+     * Lifecycle trigger: after command execution.
+     */
+    static triggerAfterCommand(commandName: string, result: any): Promise<void>;
+    /**
+     * Scans loaded plugins and lets them inject their custom subcommands.
+     */
+    static injectCustomCommands(program: Command): void;
+}

package/dist/plugins/index.js

@@ -0,0 +1,61 @@
+export class PluginRegistry {
+    static plugins = new Map();
+    /**
+     * Registers a plugin instance.
+     */
+    static registerPlugin(plugin) {
+        this.plugins.set(plugin.name, plugin);
+        // console.log(`[PluginRegistry] Registered: ${plugin.name} (v${plugin.version})`);
+    }
+    /**
+     * Retrieves all loaded plugins.
+     */
+    static getPlugins() {
+        return Array.from(this.plugins.values());
+    }
+    /**
+     * Lifecycle trigger: before command execution.
+     */
+    static async triggerBeforeCommand(commandName, args) {
+        for (const plugin of this.plugins.values()) {
+            if (plugin.beforeCommand) {
+                try {
+                    await plugin.beforeCommand(commandName, args);
+                }
+                catch (err) {
+                    console.warn(`[PluginRegistry] Plugin "${plugin.name}" error in beforeCommand:`, err);
+                }
+            }
+        }
+    }
+    /**
+     * Lifecycle trigger: after command execution.
+     */
+    static async triggerAfterCommand(commandName, result) {
+        for (const plugin of this.plugins.values()) {
+            if (plugin.afterCommand) {
+                try {
+                    await plugin.afterCommand(commandName, result);
+                }
+                catch (err) {
+                    console.warn(`[PluginRegistry] Plugin "${plugin.name}" error in afterCommand:`, err);
+                }
+            }
+        }
+    }
+    /**
+     * Scans loaded plugins and lets them inject their custom subcommands.
+     */
+    static injectCustomCommands(program) {
+        for (const plugin of this.plugins.values()) {
+            if (plugin.registerCustomCommands) {
+                try {
+                    plugin.registerCustomCommands(program);
+                }
+                catch (err) {
+                    console.error(`[PluginRegistry] Plugin "${plugin.name}" failed to register custom commands:`, err);
+                }
+            }
+        }
+    }
+}

package/dist/tests/test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/test.js

@@ -0,0 +1,108 @@
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import sharp from 'sharp';
+import { ConfigManager } from '../core/config/index.js';
+import { ImageEngine } from '../core/image/index.js';
+import { QrEngine } from '../core/qr/index.js';
+import { ExportEngine } from '../core/export/index.js';
+async function runTests() {
+    console.log(chalk.bold.cyan('========================================'));
+    console.log(chalk.bold.cyan('    MediaGuru Engine Validation Suite    '));
+    console.log(chalk.bold.cyan('========================================\n'));
+    const testDir = './test_sandbox';
+    if (!fs.existsSync(testDir)) {
+        fs.mkdirSync(testDir, { recursive: true });
+    }
+    // Setup Config
+    ConfigManager.update({
+        outputFolder: testDir,
+        compressionQuality: 85,
+        defaultImageFormat: 'png',
+    });
+    console.log(chalk.green('✓ Config Manager initialized and updated.'));
+    // Create mock source image (100x100 solid blue box)
+    const mockImagePath = path.join(testDir, 'source.png');
+    const mockWatermarkPath = path.join(testDir, 'watermark.png');
+    await sharp({
+        create: {
+            width: 200,
+            height: 200,
+            channels: 4,
+            background: { r: 0, g: 0, b: 255, alpha: 1 },
+        },
+    })
+        .png()
+        .toFile(mockImagePath);
+    // Solid white 40x40 watermark box
+    await sharp({
+        create: {
+            width: 40,
+            height: 40,
+            channels: 4,
+            background: { r: 255, g: 255, b: 255, alpha: 1 },
+        },
+    })
+        .png()
+        .toFile(mockWatermarkPath);
+    console.log(chalk.green('✓ Mock testing images created successfully.'));
+    // Test Image Resize
+    console.log(chalk.yellow('\nTesting Image Resizing...'));
+    const resizedPath = await ImageEngine.resize(mockImagePath, '100x100');
+    if (fs.existsSync(resizedPath)) {
+        console.log(chalk.green(`✓ Image resized successfully: ${resizedPath}`));
+    }
+    else {
+        throw new Error('Image resize failed to output file.');
+    }
+    // Test Image Format Convert
+    console.log(chalk.yellow('\nTesting Image Conversion...'));
+    const convertedPath = await ImageEngine.convert(mockImagePath, 'webp');
+    if (fs.existsSync(convertedPath)) {
+        console.log(chalk.green(`✓ Image converted to WebP successfully: ${convertedPath}`));
+    }
+    else {
+        throw new Error('Image conversion failed to output file.');
+    }
+    // Test Image Watermark
+    console.log(chalk.yellow('\nTesting Image Watermarking...'));
+    const watermarkedPath = await ImageEngine.watermark(mockImagePath, mockWatermarkPath);
+    if (fs.existsSync(watermarkedPath)) {
+        console.log(chalk.green(`✓ Watermark overlay successful: ${watermarkedPath}`));
+    }
+    else {
+        throw new Error('Watermark overlay failed to output file.');
+    }
+    // Test QR Generator
+    console.log(chalk.yellow('\nTesting QR Code Generation...'));
+    const qrPng = await QrEngine.generate('https://kontyra.com', { svg: false, size: 250 });
+    const qrSvg = await QrEngine.generate('https://kontyra.com', { svg: true, size: 250 });
+    if (fs.existsSync(qrPng) && fs.existsSync(qrSvg)) {
+        console.log(chalk.green(`✓ QR PNG generated successfully: ${qrPng}`));
+        console.log(chalk.green(`✓ QR SVG generated successfully: ${qrSvg}`));
+    }
+    else {
+        throw new Error('QR Code generation failed.');
+    }
+    // Test Exports System
+    console.log(chalk.yellow('\nTesting Exports System...'));
+    const configJson = await ExportEngine.exportConfig('json', { outputPath: path.join(testDir, 'config.json') });
+    const configMd = await ExportEngine.exportConfig('markdown', { outputPath: path.join(testDir, 'config.md') });
+    const configCsv = await ExportEngine.exportConfig('csv', { outputPath: path.join(testDir, 'config.csv') });
+    if (fs.existsSync(configJson) && fs.existsSync(configMd) && fs.existsSync(configCsv)) {
+        console.log(chalk.green('✓ Configurations exported successfully in JSON, MD, and CSV.'));
+    }
+    else {
+        throw new Error('Export config failed.');
+    }
+    // Clean up mock generated source files
+    console.log(chalk.cyan('\nCleaning up mock testing files...'));
+    // (we leave other outputs in the sandbox folder for manual inspection if needed)
+    console.log(chalk.bold.green('\n========================================'));
+    console.log(chalk.bold.green('      ALL CORE ENGINE TESTS PASSED!      '));
+    console.log(chalk.bold.green('========================================\n'));
+}
+runTests().catch((err) => {
+    console.error(chalk.bold.red('\n❌ TEST SUITE FAILED:'), err);
+    process.exit(1);
+});

package/dist/tests/test_playwright.d.ts

@@ -0,0 +1 @@
+export {};