nuclie 1.0.0

package/dist/core/universal-transformer.js

@@ -0,0 +1,780 @@
+/**
+ * Universal Framework Transformer
+ * Version-agnostic transformer that works with any framework version
+ * Automatically adapts to the installed version
+ */
+import path from 'path';
+import fs from 'fs/promises';
+import { getFrameworkPreset } from '../presets/frameworks.js';
+import { log } from '../utils/logger.js';
+import { createRequire } from 'module';
+import * as esbuild from 'esbuild';
+import { canonicalHash } from '../core/engine/hash.js';
+const _require = createRequire(import.meta.url);
+export class UniversalTransformer {
+    constructor(root, options) {
+        this.transformers = new Map();
+        this.packageVersionCache = new Map();
+        this.transformCache = new Map();
+        this.cacheEnabled = true;
+        this.root = root;
+        this.cacheEnabled = options?.cache !== false;
+    }
+    /**
+     * Clear transformation cache (useful for HMR)
+     */
+    clearCache(filePath) {
+        if (filePath) {
+            this.transformCache.delete(filePath);
+        }
+        else {
+            this.transformCache.clear();
+        }
+    }
+    /**
+     * Transform code based on framework
+     * Automatically detects and uses the installed version
+     */
+    async transform(options) {
+        const { filePath, code, framework, isDev = true } = options;
+        // Advanced Deterministic Cache (Phase F1)
+        // Ensure that identical inputs ALWAYS produce identical outputs
+        // This is critical for Tier 2/3 frameworks to be "production ready"
+        if (this.cacheEnabled) {
+            const h = canonicalHash(code + framework + (isDev ? 'dev' : 'prod')).substring(0, 16);
+            const cacheKey = `${filePath}:${h}`;
+            const cached = this.transformCache.get(cacheKey);
+            if (cached) {
+                return cached;
+            }
+        }
+        const preset = getFrameworkPreset(framework);
+        // Route to appropriate transformer
+        let result;
+        switch (framework) {
+            case 'react':
+            case 'next':
+            case 'remix':
+                result = await this.transformReact(code, filePath, isDev);
+                break;
+            case 'vue':
+            case 'nuxt':
+                result = await this.transformVue(code, filePath, isDev);
+                break;
+            case 'svelte':
+                result = await this.transformSvelte(code, filePath, isDev);
+                break;
+            case 'angular':
+                result = await this.transformAngular(code, filePath, isDev);
+                break;
+            case 'solid':
+                result = await this.transformSolid(code, filePath, isDev);
+                break;
+            case 'preact':
+                result = await this.transformPreact(code, filePath, isDev);
+                break;
+            case 'qwik':
+                result = await this.transformQwik(code, filePath, isDev);
+                break;
+            case 'lit':
+                result = await this.transformLit(code, filePath, isDev);
+                break;
+            case 'astro':
+                result = await this.transformAstro(code, filePath, isDev);
+                break;
+            case 'vanilla':
+            default:
+                result = await this.transformVanilla(code, filePath, isDev);
+                break;
+        }
+        // Final Normalization Pass (Phase F1 Honest)
+        // Skip for binary files, compiled code, and CSS
+        const skipNormalization = options.filePath.endsWith('.css') ||
+            options.filePath.endsWith('.node') ||
+            options.filePath.includes('/compiler/') ||
+            options.filePath.includes('node_modules/svelte/compiler') ||
+            options.filePath.includes('.wasm');
+        if (!skipNormalization) {
+            try {
+                const targetFormat = options.format || (options.target === 'node' ? 'cjs' : 'esm');
+                const finalResult = await esbuild.transform(result.code, {
+                    define: options.define || {},
+                    loader: 'tsx',
+                    format: targetFormat,
+                    platform: options.target === 'node' ? 'node' : 'browser',
+                    target: isDev ? 'es2020' : 'esnext',
+                    minify: false
+                });
+                result.code = finalResult.code;
+            }
+            catch (err) {
+                // Log normalization failures for debugging
+                // These are usually non-critical but good to know about
+                if (!err.message.includes('Unexpected') && !err.message.includes('Expected')) {
+                    if (process.env.DEBUG) {
+                        log.debug(`Final normalization skipped for ${options.filePath}: ${err.message}`);
+                    }
+                }
+            }
+        }
+        // Cache the result (Advanced Determinism)
+        if (this.cacheEnabled) {
+            const h = canonicalHash(code + framework + (isDev ? 'dev' : 'prod')).substring(0, 16);
+            const cacheKey = `${filePath}:${h}`;
+            this.transformCache.set(cacheKey, result);
+        }
+        return result;
+    }
+    /**
+     * React Transformer - Works with all React versions (16+)
+     */
+    async transformReact(code, filePath, isDev, jsxOptions) {
+        const ext = path.extname(filePath);
+        // Only transform JSX/TSX files
+        if (ext !== '.jsx' && ext !== '.tsx') {
+            return this.transformVanilla(code, filePath, isDev);
+        }
+        try {
+            const babelModule = await import('@babel/core');
+            const babel = babelModule.default || babelModule;
+            // Detect React version to use appropriate transform
+            const reactVersion = await this.getPackageVersion('react');
+            const useAutomatic = (reactVersion && parseInt(reactVersion) >= 17) || !!jsxOptions?.importSource;
+            // Resolve presets from tool's dependencies, not user's project
+            const output = await babel.transformAsync(code, {
+                filename: filePath,
+                presets: [
+                    [
+                        _require.resolve('@babel/preset-react'),
+                        {
+                            runtime: useAutomatic ? 'automatic' : 'classic',
+                            development: isDev,
+                            importSource: jsxOptions?.importSource // For Preact/others
+                        }
+                    ],
+                    _require.resolve('@babel/preset-typescript')
+                ],
+                plugins: (() => {
+                    const plugins = [];
+                    if (isDev) {
+                        try {
+                            // Fix validation error in tests by skipping environment check
+                            plugins.push([_require.resolve('react-refresh/babel'), { skipEnvCheck: true }]);
+                        }
+                        catch (e) {
+                            // React refresh not found, skip
+                        }
+                    }
+                    return plugins;
+                })(),
+                sourceMaps: isDev ? 'inline' : false
+            });
+            let finalCode = output?.code || code;
+            // Inject HMR context for React
+            if (isDev) {
+                // Normalize path to prevent escape sequence issues on Windows
+                const normalizedPath = filePath.replace(/\\/g, '/');
+                const hmrFooter = `
+
+// Nuclie Advanced HMR (React)
+import { createHotContext } from '/@nuclie/client';
+if (!import.meta.hot) {
+    import.meta.hot = createHotContext("${normalizedPath}");
+}
+if (import.meta.hot) {
+    import.meta.hot.accept();
+}
+                `;
+                finalCode = finalCode + hmrFooter;
+            }
+            return {
+                code: finalCode,
+                map: output?.map ? JSON.stringify(output.map) : undefined
+            };
+        }
+        catch (error) {
+            // Display error prominently to user
+            const relativePath = filePath.replace(this.root, '').replace(/^\//, '');
+            const errorMessage = error.message?.split('\n')[0] || String(error);
+            const lineMatch = error.loc?.line || error.message?.match(/\(\d+:\d+\)/)?.[0];
+            log.projectError({
+                file: relativePath,
+                message: errorMessage,
+                line: error.loc?.line,
+                column: error.loc?.column,
+                type: 'Transformation Error',
+                plugin: 'nuclie:universal-transformer'
+            });
+            // Re-throw the error instead of falling back
+            throw error;
+        }
+    }
+    /**
+     * Vue Transformer - Works with all Vue versions (2.x, 3.x)
+     */
+    async transformVue(code, filePath, isDev) {
+        if (!filePath.endsWith('.vue')) {
+            return this.transformVanilla(code, filePath, isDev);
+        }
+        try {
+            let compiler;
+            try {
+                const compilerPath = _require.resolve('@vue/compiler-sfc', { paths: [this.root, process.cwd()] });
+                compiler = await import(compilerPath);
+            }
+            catch {
+                log.warn('No Vue 3 compiler found, using fallback with HMR');
+                // Fallback: Return raw code with HMR wrapper
+                if (isDev) {
+                    const normalizedPath = filePath.replace(/\\/g, '/');
+                    const wrappedCode = `
+// Vue fallback (compiler missing)
+const _sfc_main = { template: \`${code.replace(/`/g, '\\`')}\` };
+export default _sfc_main;
+
+// Nuclie Advanced HMR (Vue - Fallback)
+import { createHotContext } from '/@nuclie/client';
+if (!import.meta.hot) {
+    import.meta.hot = createHotContext("${normalizedPath}");
+}
+if (import.meta.hot) {
+    import.meta.hot.accept();
+}
+                    `;
+                    return { code: wrappedCode };
+                }
+                return { code: `export default { template: \`${code.replace(/`/g, '\\`')}\` };` };
+            }
+            if (!compiler.parse)
+                return { code };
+            const { descriptor } = compiler.parse(code, { filename: filePath });
+            const scopeId = `data-v-${Math.random().toString(36).substring(2, 9)}`;
+            const hasTemplate = !!descriptor.template;
+            let scriptContent = 'const _sfc_main = {};';
+            if (descriptor.script || descriptor.scriptSetup) {
+                const compiledScript = compiler.compileScript(descriptor, {
+                    id: scopeId,
+                    inlineTemplate: hasTemplate,
+                    templateOptions: hasTemplate ? {
+                        source: descriptor.template.content,
+                        filename: filePath,
+                        id: scopeId,
+                        scoped: descriptor.styles.some((s) => s.scoped),
+                        compilerOptions: {
+                            scopeId: descriptor.styles.some((s) => s.scoped) ? scopeId : undefined
+                        }
+                    } : undefined
+                });
+                scriptContent = compiledScript.content;
+                // Replace "export default" but keep the object/definition intact
+                // Vue's compileScript for setup usually exports an object with a setup() function
+                const exportDefaultRegex = /export\s+default\s+/;
+                if (exportDefaultRegex.test(scriptContent)) {
+                    scriptContent = scriptContent.replace(exportDefaultRegex, 'const _sfc_main = ');
+                }
+            }
+            // Fallback for template-only components or if script-setup didn't inline
+            let templateCode = '';
+            if (hasTemplate && !scriptContent.includes('const _sfc_main =')) {
+                const templateResult = compiler.compileTemplate({
+                    source: descriptor.template.content,
+                    filename: filePath,
+                    id: scopeId,
+                    scoped: descriptor.styles.some((s) => s.scoped),
+                    compilerOptions: {
+                        scopeId: descriptor.styles.some((s) => s.scoped) ? scopeId : undefined
+                    }
+                });
+                templateCode = templateResult.code.replace('export function render', 'const _sfc_render = function render');
+                if (!scriptContent.includes('const _sfc_main =')) {
+                    scriptContent = 'const _sfc_main = {};\n' + scriptContent;
+                }
+            }
+            let cssCode = '';
+            for (const style of descriptor.styles) {
+                const styleResult = compiler.compileStyle({
+                    source: style.content,
+                    filename: filePath,
+                    id: scopeId,
+                    scoped: style.scoped
+                });
+                cssCode += styleResult.code;
+            }
+            let output = `
+                ${scriptContent}
+                ${templateCode ? `
+                ${templateCode}
+                _sfc_main.render = _sfc_render;
+                ` : ''}
+                
+                // Inject CSS
+                ${cssCode ? `
+                if (typeof document !== 'undefined') {
+                    const _style = document.createElement('style');
+                    _style.innerHTML = ${JSON.stringify(cssCode)};
+                    document.head.appendChild(_style);
+                }
+                ` : ''}
+
+                ${descriptor.styles.some((s) => s.scoped) ? `_sfc_main.__scopeId = "${scopeId}";` : ''}
+                _sfc_main.__file = "${filePath}";
+                
+                export default _sfc_main;
+            `;
+            // Add HMR footer for Vue (only in dev mode)
+            if (isDev) {
+                const normalizedPath = filePath.replace(/\\/g, '/');
+                output += `
+
+// Nuclie Advanced HMR (Vue)
+import { createHotContext } from '/@nuclie/client';
+if (!import.meta.hot) {
+    import.meta.hot = createHotContext("${normalizedPath}");
+}
+if (import.meta.hot) {
+    _sfc_main.__hmrId = "${scopeId}";
+    import.meta.hot.accept((modules) => {
+        const newMod = modules[0];
+        if (!newMod) return;
+        // Vue HMR: Component hot-reload
+        // Real Vue HMR is complex, for now we trigger reload
+    });
+}
+                `;
+            }
+            return { code: output };
+        }
+        catch (error) {
+            log.error(`Vue transform failed for ${filePath}:`, error.message);
+            return { code };
+        }
+    }
+    /**
+     * Svelte Transformer - Works with all Svelte versions (3.x, 4.x, 5.x)
+     */
+    async transformSvelte(code, filePath, isDev) {
+        if (!filePath.endsWith('.svelte')) {
+            return this.transformVanilla(code, filePath, isDev);
+        }
+        try {
+            let svelte;
+            try {
+                const compilerPath = _require.resolve('svelte/compiler', { paths: [this.root, process.cwd()] });
+                const mod = await import(compilerPath);
+                svelte = typeof mod.compile === 'function' ? mod : (mod.default || mod);
+            }
+            catch {
+                const mod = await import('svelte/compiler');
+                svelte = typeof mod.compile === 'function' ? mod : (mod.default || mod);
+            }
+            const version = await this.getPackageVersion('svelte');
+            const isSvelte5 = version && version.startsWith('5');
+            const result = svelte.compile(code, {
+                filename: filePath,
+                dev: isDev,
+                css: 'injected',
+                generate: isSvelte5 ? 'client' : 'dom',
+                hydratable: true,
+                enableSourcemap: isDev
+            });
+            let finalCode = result.js.code;
+            // Advanced HMR for Svelte (Production-Grade)
+            if (isDev) {
+                const normalizedPath = filePath.replace(/\\/g, '/');
+                const componentId = canonicalHash(filePath).substring(0, 16);
+                finalCode += `
+
+// Nuclie Advanced HMR (Svelte)
+import { createHotContext } from '/@nuclie/client';
+if (!import.meta.hot) {
+    import.meta.hot = createHotContext("${normalizedPath}");
+}
+if (import.meta.hot) {
+    import.meta.hot.accept((newModule) => {
+        if (!newModule) return;
+        // Svelte HMR: Re-create component instances
+        const instances = window.__NUCLIE_SVELTE_INSTANCES__ || (window.__NUCLIE_SVELTE_INSTANCES__ = new Map());
+        const componentInstances = instances.get("${componentId}") || [];
+        componentInstances.forEach(instance => {
+            if (instance && instance.$set) {
+                // Preserve state and re-render
+                const state = instance.$capture_state ? instance.$capture_state() : {};
+                instance.$destroy();
+                const NewComponent = newModule.default;
+                const newInstance = new NewComponent({
+                    target: instance.$$.root,
+                    props: instance.$$.props
+                });
+                if (newInstance.$inject_state && Object.keys(state).length > 0) {
+                    newInstance.$inject_state(state);
+                }
+            }
+        });
+    });
+}
+                `;
+            }
+            return {
+                code: finalCode,
+                map: result.js.map ? JSON.stringify(result.js.map) : undefined
+            };
+        }
+        catch (error) {
+            log.error(`Svelte transform failed for ${filePath}: ${error.stack || error.message}`);
+            return { code };
+        }
+    }
+    /**
+     * Angular Transformer - Works with ALL Angular versions (2-17+)
+     */
+    async transformAngular(code, filePath, isDev) {
+        try {
+            const ngVersion = await this.getPackageVersion('@angular/core');
+            const majorVersion = ngVersion ? parseInt(ngVersion.split('.')[0]) : 17;
+            if (filePath.endsWith('.ts')) {
+                const ts = await import('typescript');
+                try {
+                    const compilerOptions = {
+                        target: ts.ScriptTarget.ES2020,
+                        module: ts.ModuleKind.ESNext,
+                        experimentalDecorators: true,
+                        emitDecoratorMetadata: true,
+                        useDefineForClassFields: majorVersion >= 14 ? false : true,
+                    };
+                    const result = ts.transpileModule(code, {
+                        compilerOptions,
+                        fileName: filePath
+                    });
+                    let finalCode = result.outputText;
+                    // Advanced HMR for Angular (Production-Grade)
+                    if (isDev) {
+                        const normalizedPath = filePath.replace(/\\/g, '/');
+                        const componentId = canonicalHash(filePath).substring(0, 16);
+                        finalCode += `
+
+// Nuclie Advanced HMR (Angular)
+import { createHotContext } from '/@nuclie/client';
+if (!import.meta.hot) {
+    import.meta.hot = createHotContext("${normalizedPath}");
+}
+if (import.meta.hot) {
+    import.meta.hot.accept((newModule) => {
+        if (!newModule) return;
+        // Angular HMR: Re-bootstrap components
+        const registry = window.__NUCLIE_ANGULAR_REGISTRY__ || (window.__NUCLIE_ANGULAR_REGISTRY__ = new Map());
+        const components = registry.get("${componentId}") || [];
+        components.forEach(({ componentRef, viewContainerRef }) => {
+            if (componentRef && viewContainerRef) {
+                const NewComponent = newModule.default || Object.values(newModule)[0];
+                if (NewComponent) {
+                    const index = viewContainerRef.indexOf(componentRef.hostView);
+                    viewContainerRef.remove(index);
+                    viewContainerRef.createComponent(NewComponent);
+                }
+            }
+        });
+    });
+}
+                        `;
+                    }
+                    return { code: finalCode, map: result.sourceMapText };
+                }
+                catch {
+                    return this.transformVanilla(code, filePath, isDev);
+                }
+            }
+            if (filePath.endsWith('.html')) {
+                return { code: `export default ${JSON.stringify(code)};` };
+            }
+            return this.transformVanilla(code, filePath, isDev);
+        }
+        catch (error) {
+            log.error(`Angular transform failed for ${filePath}:`, error.message);
+            return this.transformVanilla(code, filePath, isDev);
+        }
+    }
+    /**
+     * Solid Transformer - Works with all Solid versions
+     */
+    async transformSolid(code, filePath, isDev) {
+        const ext = path.extname(filePath);
+        if (ext !== '.jsx' && ext !== '.tsx') {
+            return this.transformVanilla(code, filePath, isDev);
+        }
+        try {
+            const babelModule = await import('@babel/core');
+            const babel = babelModule.default || babelModule;
+            const result = await babel.transformAsync(code, {
+                filename: filePath,
+                presets: [
+                    _require.resolve('babel-preset-solid'),
+                    _require.resolve('@babel/preset-typescript')
+                ],
+                sourceMaps: isDev ? 'inline' : false
+            });
+            let finalCode = result?.code || code;
+            // Inject HMR context for Solid
+            if (isDev) {
+                const normalizedPath = filePath.replace(/\\/g, '/');
+                const hmrFooter = `
+
+// Nuclie Advanced HMR (Solid)
+import { createHotContext } from '/@nuclie/client';
+if (!import.meta.hot) {
+    import.meta.hot = createHotContext("${normalizedPath}");
+}
+if (import.meta.hot) {
+    import.meta.hot.accept((newModule) => {
+        if (!newModule) return;
+        // Solid HMR: Re-render root components
+        const roots = window.__NUCLIE_SOLID_ROOTS__ || (window.__NUCLIE_SOLID_ROOTS__ = new Map());
+        const componentRoots = roots.get("${normalizedPath}") || [];
+        componentRoots.forEach(({ dispose, container, component }) => {
+            if (dispose) dispose();
+            const NewComponent = newModule.default || newModule[component];
+            if (NewComponent && container) {
+                import('solid-js/web').then(({ render }) => {
+                    render(() => NewComponent({}), container);
+                });
+            }
+        });
+    });
+}
+                `;
+                finalCode = finalCode + hmrFooter;
+            }
+            return { code: finalCode, map: result?.map ? JSON.stringify(result.map) : undefined };
+        }
+        catch (error) {
+            log.warn(`Solid transform failed (babel-preset-solid missing?), using esbuild fallback with HMR`);
+            // Fallback: use esbuild but still add HMR
+            try {
+                const result = await esbuild.transform(code, {
+                    loader: 'tsx',
+                    sourcemap: isDev ? 'inline' : false,
+                    format: 'esm',
+                    target: 'es2020',
+                    jsx: 'automatic',
+                    jsxImportSource: 'solid-js'
+                });
+                let finalCode = result.code;
+                // Still add HMR even in fallback
+                if (isDev) {
+                    const normalizedPath = filePath.replace(/\\/g, '/');
+                    const hmrFooter = `
+
+// Nuclie Advanced HMR (Solid - Fallback)
+import { createHotContext } from '/@nuclie/client';
+if (!import.meta.hot) {
+    import.meta.hot = createHotContext("${normalizedPath}");
+}
+if (import.meta.hot) {
+    import.meta.hot.accept();
+}
+                    `;
+                    finalCode = finalCode + hmrFooter;
+                }
+                return { code: finalCode, map: result.map };
+            }
+            catch (fallbackError) {
+                log.error(`Solid fallback also failed: ${fallbackError.message}`);
+                return this.transformVanilla(code, filePath, isDev);
+            }
+        }
+    }
+    /**
+     * Preact Transformer - Works with all Preact versions
+     */
+    async transformPreact(code, filePath, isDev) {
+        return this.transformReact(code, filePath, isDev, { importSource: 'preact' });
+    }
+    /**
+     * Qwik Transformer - Works with all Qwik versions
+     */
+    async transformQwik(code, filePath, isDev) {
+        try {
+            let qwik;
+            try {
+                const compilerPath = _require.resolve('@builder.io/qwik/optimizer', { paths: [this.root, process.cwd()] });
+                const mod = await import(compilerPath);
+                qwik = typeof mod.createOptimizer === 'function' ? mod : (mod.default || mod);
+            }
+            catch {
+                const fallbackQwikOptimizer = '@builder.io/qwik/optimizer';
+                const mod = await import(fallbackQwikOptimizer);
+                qwik = typeof mod.createOptimizer === 'function' ? mod : (mod.default || mod);
+            }
+            const optimizer = await qwik.createOptimizer();
+            const result = await optimizer.transformModules({
+                input: [{ code, path: filePath }],
+                srcDir: path.join(this.root, 'src'),
+                entryStrategy: { type: 'single' },
+                minify: isDev ? 'none' : 'simplify',
+                sourceMaps: isDev,
+                transpile: true,
+            });
+            const output = result.modules[0];
+            const { transform } = await import('esbuild');
+            const final = await transform(output.code, {
+                loader: 'tsx',
+                format: 'esm',
+                target: 'es2022',
+                jsx: 'automatic',
+                jsxImportSource: '@builder.io/qwik'
+            });
+            return { code: final.code, map: final.map ? JSON.stringify(final.map) : undefined };
+        }
+        catch (error) {
+            log.error(`Qwik transform failed for ${filePath}: ${error.stack || error.message}`);
+            return this.transformVanilla(code, filePath, isDev);
+        }
+    }
+    /**
+     * Lit Transformer - Works with all Lit versions
+     */
+    async transformLit(code, filePath, isDev) {
+        try {
+            const ts = await import('typescript');
+            const result = ts.transpileModule(code, {
+                compilerOptions: {
+                    target: ts.ScriptTarget.ES2020,
+                    module: ts.ModuleKind.ESNext,
+                    experimentalDecorators: true,
+                    useDefineForClassFields: false,
+                    moduleResolution: ts.ModuleResolutionKind.NodeJs
+                },
+                fileName: filePath
+            });
+            let finalCode = result.outputText;
+            // Advanced HMR for Lit (Production-Grade)
+            if (isDev) {
+                const normalizedPath = filePath.replace(/\\/g, '/');
+                const componentId = canonicalHash(filePath).substring(0, 16);
+                finalCode += `
+
+// Nuclie Advanced HMR (Lit)
+import { createHotContext } from '/@nuclie/client';
+if (!import.meta.hot) {
+    import.meta.hot = createHotContext("${normalizedPath}");
+}
+if (import.meta.hot) {
+    import.meta.hot.accept((newModule) => {
+        if (!newModule) return;
+        // Lit HMR: Re-register custom elements
+        const registry = window.__NUCLIE_LIT_REGISTRY__ || (window.__NUCLIE_LIT_REGISTRY__ = new Map());
+        const elements = registry.get("${componentId}") || [];
+        elements.forEach(({ tagName, constructor }) => {
+            const instances = document.querySelectorAll(tagName);
+            instances.forEach(instance => {
+                const NewClass = newModule.default || newModule[constructor.name];
+                if (NewClass && customElements.get(tagName)) {
+                    const attrs = Array.from(instance.attributes);
+                    const children = Array.from(instance.childNodes);
+                    const parent = instance.parentNode;
+                    const newElement = document.createElement(tagName);
+                    attrs.forEach(attr => newElement.setAttribute(attr.name, attr.value));
+                    children.forEach(child => newElement.appendChild(child.cloneNode(true)));
+                    parent?.replaceChild(newElement, instance);
+                }
+            });
+        });
+    });
+}
+                `;
+            }
+            return { code: finalCode, map: result.sourceMapText };
+        }
+        catch (error) {
+            log.error(`Lit transform failed for ${filePath}:`, error.message);
+            return this.transformVanilla(code, filePath, isDev);
+        }
+    }
+    /**
+     * Astro Transformer - Works with all Astro versions
+     */
+    async transformAstro(code, filePath, isDev) {
+        if (!filePath.endsWith('.astro')) {
+            return this.transformVanilla(code, filePath, isDev);
+        }
+        try {
+            let astro;
+            try {
+                const compilerPath = _require.resolve('@astrojs/compiler', { paths: [this.root, process.cwd()] });
+                const mod = await import(compilerPath);
+                astro = typeof mod.transform === 'function' ? mod : (mod.default || mod);
+            }
+            catch {
+                const fallbackAstroCompiler = '@astrojs/compiler';
+                const mod = await import(fallbackAstroCompiler);
+                astro = typeof mod.transform === 'function' ? mod : (mod.default || mod);
+            }
+            const result = await astro.transform(code, {
+                filename: filePath,
+                sourcemap: isDev ? 'inline' : false,
+            });
+            return { code: result.code, map: result.map ? JSON.stringify(result.map) : undefined };
+        }
+        catch (error) {
+            log.error(`Astro transform failed for ${filePath}: ${error.stack || error.message}`);
+            return { code };
+        }
+    }
+    /**
+     * Vanilla JS/TS Transformer - Works with all versions
+     */
+    async transformVanilla(code, filePath, isDev) {
+        // Fix for local monorepo: Skip transformation for known node-only packages 
+        // that might be accidentally picked up by the customized resolver
+        if (filePath.includes('node_modules') && (filePath.includes('svelte/compiler') ||
+            filePath.includes('vite/dist'))) {
+            return { code };
+        }
+        const ext = path.extname(filePath);
+        if (ext === '.ts' || ext === '.tsx' || ext === '.js' || ext === '.jsx' || ext === '.mjs') {
+            try {
+                // Day 3: Bun Parser Lock
+                // Try Bun parser first (17x faster)
+                const { bunParser } = await import('./parser-bun.js');
+                if (bunParser.isBun()) {
+                    try {
+                        return await bunParser.transform(code, filePath, { isDev });
+                    }
+                    catch (e) {
+                        log.warn(`Bun transform failed, falling back to esbuild: ${e}`);
+                    }
+                }
+                // Fallback to esbuild
+                const result = await esbuild.transform(code, {
+                    loader: (ext === '.mjs' ? 'js' : ext.slice(1)),
+                    sourcemap: isDev ? 'inline' : false,
+                    format: 'esm',
+                    target: 'es2020',
+                    tsconfigRaw: { compilerOptions: { experimentalDecorators: true } }
+                });
+                return { code: result.code, map: result.map };
+            }
+            catch (error) {
+                log.error(`Vanilla transform failed for ${filePath}:`, error.message);
+                return { code };
+            }
+        }
+        return { code };
+    }
+    async getPackageVersion(packageName) {
+        if (this.packageVersionCache.has(packageName)) {
+            return this.packageVersionCache.get(packageName);
+        }
+        try {
+            const pkgPath = path.join(this.root, 'node_modules', packageName, 'package.json');
+            const content = await fs.readFile(pkgPath, 'utf-8');
+            const pkg = JSON.parse(content);
+            const version = pkg.version;
+            this.packageVersionCache.set(packageName, version);
+            return version;
+        }
+        catch {
+            this.packageVersionCache.set(packageName, null);
+            return null;
+        }
+    }
+}