nuclie 1.0.0

package/dist/resolve/graph.js

@@ -0,0 +1,232 @@
+import { createRequire } from 'module';
+const _require = createRequire(import.meta.url);
+import { canonicalHash } from '../core/engine/hash.js';
+import { normalizePath, generateModuleId } from './utils.js';
+import fs from 'fs/promises';
+import { existsSync } from 'fs';
+import path from 'path';
+import { scanImports } from '../native/index.js';
+import { log } from '../utils/logger.js';
+export class DependencyGraph {
+    constructor(pluginManager) {
+        this.nodes = new Map();
+        this.graphHash = '';
+        this.pluginManager = null;
+        this.pluginManager = pluginManager || null;
+    }
+    async addEntry(entryPath, rootDir) {
+        const normalized = normalizePath(entryPath);
+        const type = this.detectType(normalized);
+        const id = generateModuleId(type, normalized, rootDir);
+        const queue = [{ id, type, absPath: normalized }];
+        const visited = new Set();
+        while (queue.length > 0) {
+            const currentBatch = queue.splice(0, 100);
+            await Promise.all(currentBatch.map(async (item) => {
+                if (visited.has(item.id))
+                    return;
+                visited.add(item.id);
+                const newDeps = await this.scanAndAdd(item.id, item.type, item.absPath, rootDir);
+                for (const dep of newDeps) {
+                    if (!visited.has(dep.id)) {
+                        queue.push(dep);
+                    }
+                }
+            }));
+        }
+    }
+    detectType(p) {
+        if (p.endsWith('.module.css'))
+            return 'css-module';
+        if (p.endsWith('.css'))
+            return 'css';
+        if (p.endsWith('.vue'))
+            return 'file';
+        if (p.endsWith('.svelte'))
+            return 'file';
+        if (p.endsWith('.astro'))
+            return 'file';
+        const ext = path.extname(p).toLowerCase();
+        if (['.png', '.jpg', '.jpeg', '.gif', '.svg', '.webp', '.woff', '.woff2', '.ttf'].includes(ext)) {
+            return 'style-asset';
+        }
+        return 'file';
+    }
+    async scanAndAdd(id, type, absPath, rootDir) {
+        if (this.nodes.has(id))
+            return [];
+        const node = {
+            id,
+            type,
+            path: absPath,
+            contentHash: '', // Set after loading
+            edges: [],
+            metadata: {},
+            specifierMap: {},
+            target: 'universal'
+        };
+        // Use Plugin Manager to load content if available (supports assets, etc.)
+        let content = '';
+        if (this.pluginManager) {
+            const loadResult = await this.pluginManager.runHook('load', { id, path: absPath }, { rootDir });
+            if (loadResult && loadResult.code !== undefined) {
+                content = loadResult.code;
+            }
+        }
+        if (!content) {
+            try {
+                content = await fs.readFile(absPath, 'utf-8');
+            }
+            catch (e) {
+                return [];
+            }
+        }
+        // NEW: Transform Specialty Files so we can scan their imports correctly
+        if (this.pluginManager && (absPath.endsWith('.vue') || absPath.endsWith('.svelte') || absPath.endsWith('.astro'))) {
+            const transformResult = await this.pluginManager.runHook('transformModule', {
+                code: content,
+                path: absPath,
+                id,
+                mode: 'development' // Use dev mode for scanning
+            }, { rootDir });
+            if (transformResult && transformResult.code) {
+                content = transformResult.code;
+            }
+        }
+        node.contentHash = canonicalHash(content);
+        const imports = await this.parseImportsSimple(content, absPath, rootDir);
+        const discovered = [];
+        for (const imp of imports) {
+            const depType = this.detectType(imp.resolved);
+            const depId = generateModuleId(depType, imp.resolved, rootDir);
+            node.edges.push({
+                from: id,
+                to: depId,
+                kind: imp.kind,
+                target: 'universal'
+            });
+            // Populate specifierMap for the Linker plugin
+            if (node.specifierMap) {
+                node.specifierMap[imp.original] = depId;
+            }
+            discovered.push({ id: depId, type: depType, absPath: imp.resolved });
+        }
+        this.nodes.set(id, node);
+        return discovered;
+    }
+    async parseImportsSimple(content, filePath, rootDir) {
+        const ext = path.extname(filePath);
+        if (!['.js', '.ts', '.jsx', '.tsx', '.mjs', '.cjs', '.vue', '.svelte', '.astro'].includes(ext))
+            return [];
+        let specifiers = [];
+        try {
+            // Filter out obvious noise from native scanner
+            specifiers = scanImports(content).filter((s) => s && s.length > 0 &&
+                !s.includes(' ') &&
+                s !== 'specifier' &&
+                s !== '...' &&
+                !s.includes('${') &&
+                !s.includes('`'));
+        }
+        catch (e) {
+            // ignore
+        }
+        // Capture standard import/export strings
+        const matches = content.matchAll(/(?:import|export)\s+(?:.*?\s+from\s+)?['"](.*?)['"]/g);
+        for (const m of matches) {
+            const s = m[1];
+            if (s && !specifiers.includes(s) && !s.includes(' ') && s.length < 500) {
+                specifiers.push(s);
+            }
+        }
+        const sideEffectMatches = content.matchAll(/import\s+['"](.*?)['"]/g);
+        for (const m of sideEffectMatches) {
+            const s = m[1];
+            if (s && !specifiers.includes(s) && !s.includes(' ') && s.length < 500) {
+                specifiers.push(s);
+            }
+        }
+        const results = [];
+        for (const s of specifiers) {
+            const resolved = await this.resolve(s, filePath);
+            if (resolved) {
+                results.push({ original: s, resolved, kind: 'import' });
+            }
+            else {
+                // PRODUCTION NOISE REDUCTION:
+                // 1. Only warn if the file is in the project's root source
+                // 2. Ignore nuclie internal paths and node_modules
+                const isProjectFile = rootDir ? filePath.startsWith(rootDir) : !filePath.includes('node_modules');
+                const isInternalFile = filePath.includes('/build/dist/') || filePath.includes('/build/src/') || filePath.includes('/build/native/');
+                if (isProjectFile && !isInternalFile && !filePath.includes('node_modules')) {
+                    // Only warn for relatively clear "missing project file" cases (relative paths)
+                    if (s.startsWith('.') || s.startsWith('@/')) {
+                        log.warn(`Failed to resolve specifier: ${s} from ${filePath}`);
+                    }
+                    else {
+                        // Packages failure is debug only unless it's a critical entry point
+                        log.debug(`Module not found: ${s} from ${filePath}`);
+                    }
+                }
+            }
+        }
+        return results;
+    }
+    async resolve(specifier, importer) {
+        if (specifier.startsWith('.')) {
+            const abs = path.resolve(path.dirname(importer), specifier);
+            const candidates = [
+                abs,
+                abs + '.ts',
+                abs + '.tsx',
+                abs + '.js',
+                abs + '.vue',
+                abs + '.svelte',
+                abs + '/index.ts',
+                abs + '/index.js'
+            ];
+            for (const c of candidates) {
+                if (existsSync(c))
+                    return normalizePath(c);
+            }
+        }
+        // Deep Scan node_modules for framework packages
+        if (!specifier.startsWith('./') && !specifier.startsWith('../') && !specifier.startsWith('/')) {
+            try {
+                const resolved = _require.resolve(specifier, { paths: [path.dirname(importer), process.cwd()] });
+                if (resolved)
+                    return normalizePath(resolved);
+            }
+            catch (e) {
+                // ignore
+            }
+        }
+        return null;
+    }
+    async invalidate(filePath, rootDir) {
+        const normalized = normalizePath(filePath);
+        const type = this.detectType(normalized);
+        const id = generateModuleId(type, normalized, rootDir);
+        this.nodes.delete(id);
+        await this.addEntry(filePath, rootDir);
+    }
+    validate() {
+        return { isValid: true, cycles: [], errors: [] };
+    }
+    getReachableNodes(entryPoints) {
+        const visited = new Set();
+        const queue = [...entryPoints];
+        while (queue.length > 0) {
+            const curr = queue.shift();
+            if (visited.has(curr))
+                continue;
+            visited.add(curr);
+            const node = this.nodes.get(curr);
+            if (node) {
+                for (const edge of node.edges)
+                    queue.push(edge.to);
+            }
+        }
+        return Array.from(visited);
+    }
+}

package/dist/resolve/utils.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Phase 1: Path Normalization
+ *
+ * Ensures consistent paths across OS environments to guarantee graph determinism.
+ *
+ * Rules:
+ * 1. Always use forward slashes (POSIX style).
+ * 2. Resolve to absolute paths internally, but use relative for ID generation where possible.
+ * 3. No symlinks leaking (User must resolve them before passing, or we resolve here).
+ * 4. Lowercase drive letters on Windows (c:/ vs C:/).
+ */
+export declare function normalizePath(p: string): string;
+export declare function generateModuleId(type: 'file' | 'virtual' | 'css' | 'css-module' | 'style-asset' | 'css-in-js', normalizedPath: string, rootDir?: string): string;

package/dist/resolve/utils.js

@@ -0,0 +1,53 @@
+import path from 'path';
+/**
+ * Phase 1: Path Normalization
+ *
+ * Ensures consistent paths across OS environments to guarantee graph determinism.
+ *
+ * Rules:
+ * 1. Always use forward slashes (POSIX style).
+ * 2. Resolve to absolute paths internally, but use relative for ID generation where possible.
+ * 3. No symlinks leaking (User must resolve them before passing, or we resolve here).
+ * 4. Lowercase drive letters on Windows (c:/ vs C:/).
+ */
+export function normalizePath(p) {
+    // 1. Resolve to absolute path if not already
+    let abs = path.isAbsolute(p) ? p : path.resolve(p);
+    // 2. Normalize separators to forward slashes
+    // We replace all backslashes first to handle mixed paths, then ensure consistency
+    abs = abs.replace(/\\/g, '/');
+    // 3. Handle Windows Drive Letters (c:/users... vs C:/Users...)
+    if (/^[a-zA-Z]:\//.test(abs)) {
+        abs = abs.charAt(0).toLowerCase() + abs.slice(1);
+    }
+    // 4. Remove trailing slashes unless root
+    if (abs.length > 3 && abs.endsWith('/')) {
+        abs = abs.slice(0, -1);
+    }
+    return abs;
+}
+/**
+ * Generates a deterministic ID for a module based on its type and path.
+ *
+ * In a real build, we might want IDs relative to root for portability.
+ * For now, we use the normalized absolute path to ensure uniqueness within this machine.
+ *
+ * Future improvement: Make IDs project-root relative for remote caching.
+ */
+import { canonicalHash } from '../core/engine/hash.js';
+export function generateModuleId(type, normalizedPath, rootDir) {
+    let key = normalizedPath;
+    if (rootDir) {
+        const normalizedRoot = normalizePath(rootDir);
+        if (normalizedPath.startsWith(normalizedRoot)) {
+            // path.relative on Windows expects native slashes to work reliably for drive letters
+            const nativePath = normalizedPath.replace(/\//g, path.sep);
+            const nativeRoot = normalizedRoot.replace(/\//g, path.sep);
+            key = path.relative(nativeRoot, nativePath).replace(/\\/g, '/');
+        }
+    }
+    // We hash the key (type + path) to get a fixed-length ID, 
+    // or we could use the path directly if readability is preferred.
+    // Spec says: "GraphNode.id = canonicalHash(type + normalizedPath)"
+    return canonicalHash({ type, path: key });
+}

package/dist/runtime/client.d.ts

@@ -0,0 +1,9 @@
+import './error-overlay.js';
+export declare function createHotContext(ownerPath: string): {
+    readonly data: any;
+    accept(deps: string | string[] | ((modules: any[]) => void), callback?: (modules: any[]) => void): void;
+    dispose(cb: (data: any) => void): void;
+    decline(): void;
+    invalidate(): void;
+    on(event: string, cb: Function): void;
+};

package/dist/runtime/client.js

@@ -0,0 +1,218 @@
+/* global HTMLLinkElement */
+import './error-overlay.js';
+let overlay;
+function getOverlay() {
+    if (!overlay) {
+        overlay = document.createElement('nuclie-error-overlay');
+        document.body.appendChild(overlay);
+    }
+    return overlay;
+}
+function showError(error) {
+    const overlay = getOverlay();
+    overlay.errors = [error];
+}
+function clearErrors() {
+    if (overlay) {
+        overlay.dismiss();
+    }
+}
+// 1. Build Errors (WebSocket) & HMR
+const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+let ws;
+let reconnectAttempts = 0;
+const MAX_ATTEMPTS = 50;
+// Secure Config Sync State
+let config = null;
+let sessionToken = '';
+// HMR State
+const hotModulesMap = new Map();
+const isHmrUpdating = false;
+function connect() {
+    // Determine host: if running in proxy, might need to respect forward headers?
+    // Using window.location.host is safe for dev
+    ws = new WebSocket(`${protocol}//${window.location.host}`);
+    ws.onopen = () => {
+        // console.log('[nuclie] Connected to dev server');
+        reconnectAttempts = 0;
+        // Notify server we are ready?
+    };
+    ws.onmessage = async (event) => {
+        try {
+            const message = JSON.parse(event.data);
+            if (message.type === 'connected') {
+                console.log('[nuclie] Connected.');
+            }
+            // Security: Config Sync
+            if (message.type === 'config:init') {
+                config = message.config;
+                sessionToken = message.token;
+            }
+            if (message.type === 'config:changed') {
+                config = message.config;
+                // console.log('[nuclie] Config updated remotely:', message.update);
+            }
+            if (message.type === 'error') {
+                console.error('[nuclie] Build Error:', message.error);
+                showError({ type: 'build', ...message.error });
+            }
+            if (message.type === 'reload' || message.type === 'restarting') {
+                console.log('[nuclie] Reloading page...');
+                window.location.reload();
+            }
+            if (message.type === 'update-css') {
+                // message.path is relative path
+                const path = message.path;
+                const sheets = [].slice.call(document.getElementsByTagName('link'));
+                const head = document.getElementsByTagName('head')[0];
+                let handled = false;
+                // Handle <link> tags
+                for (let i = 0; i < sheets.length; ++i) {
+                    const elem = sheets[i];
+                    if (elem.href && elem.href.includes(path)) {
+                        const parent = elem.parentNode;
+                        const newLink = document.createElement('link');
+                        newLink.rel = 'stylesheet';
+                        newLink.href = elem.href.split('?')[0] + '?t=' + Date.now();
+                        newLink.onload = () => parent?.removeChild(elem);
+                        parent?.appendChild(newLink);
+                        handled = true;
+                    }
+                }
+                // Handle <style> tags (CSS-in-JS or Vue/Angular injections)
+                if (!handled) {
+                    // This is harder without IDs. Nuclie's CSS plugin injects with IDs?
+                    // Assuming global reload for now if not found
+                    // Or trying to find style tag with data-vite-dev-id equivalent
+                }
+                if (handled)
+                    console.log(`[nuclie] CSS updated: ${path}`);
+            }
+            if (message.type === 'update') {
+                // JS HMR Update
+                const updates = message.updates || [];
+                await applyUpdates(updates);
+            }
+        }
+        catch (e) {
+            console.error('[nuclie] Failed to parse WebSocket message', e);
+        }
+    };
+    ws.onclose = () => {
+        if (reconnectAttempts < MAX_ATTEMPTS) {
+            const timeout = Math.min(1000 * Math.pow(2, reconnectAttempts), 5000);
+            console.log(`[nuclie] Disconnected. Reconnecting in ${timeout}ms...`);
+            setTimeout(connect, timeout);
+            reconnectAttempts++;
+        }
+    };
+}
+async function applyUpdates(updates) {
+    // Simplified HMR propagation
+    for (const update of updates) {
+        const mod = hotModulesMap.get(update.path);
+        if (mod) {
+            console.log(`[nuclie] HMR Update: ${update.path}`);
+            // 1. Call dispose
+            const data = {};
+            mod.disposeCallbacks.forEach(cb => cb(data));
+            mod.data = data;
+            mod.disposeCallbacks = []; // clear after call
+            // 2. Import new module (causing re-execution)
+            try {
+                // Timestamp to bust cache
+                const newMod = await import(update.path + '?t=' + Date.now());
+                // 3. Notify acceptors
+                mod.callbacks.forEach(cb => {
+                    cb.fn([newMod]);
+                });
+            }
+            catch (e) {
+                console.error(`[nuclie] HMR Error in ${update.path}:`, e);
+                window.location.reload(); // Fallback
+            }
+        }
+        else {
+            window.location.reload(); // Full reload if not accepted
+        }
+    }
+}
+// 2. Global API
+window.nuclie = {
+    getConfig: () => config,
+    updateConfig: (path, value, persist = false) => {
+        if (ws && ws.readyState === WebSocket.OPEN) {
+            ws.send(JSON.stringify({
+                type: 'config:update',
+                token: sessionToken,
+                persist,
+                update: { path, value }
+            }));
+        }
+    }
+};
+// 3. HMR API (Vite-compatible)
+export function createHotContext(ownerPath) {
+    if (!hotModulesMap.has(ownerPath)) {
+        hotModulesMap.set(ownerPath, {
+            id: ownerPath,
+            callbacks: [],
+            disposeCallbacks: [],
+            data: {}
+        });
+    }
+    const mod = hotModulesMap.get(ownerPath);
+    return {
+        get data() {
+            return mod.data;
+        },
+        accept(deps, callback) {
+            if (typeof deps === 'function' || !deps) {
+                // Self-accept: accept(cb) or accept()
+                mod.callbacks.push({
+                    deps: [ownerPath],
+                    fn: (modules) => {
+                        if (typeof deps === 'function')
+                            deps(modules);
+                        else if (callback)
+                            callback(modules);
+                    }
+                });
+            }
+            else {
+                // Dep-accept: accept(['./foo'], cb)
+                // Nuclie v1 simplified: treat as self-accept for now or reload
+                // Proper dep support requires graph analysis on client or server sending graph
+            }
+        },
+        dispose(cb) {
+            mod.disposeCallbacks.push(cb);
+        },
+        decline() { },
+        invalidate() {
+            window.location.reload();
+        },
+        on(event, cb) {
+            // events like vite:beforeUpdate
+        }
+    };
+}
+connect();
+// Runtime Errors
+window.addEventListener('error', (event) => {
+    showError({
+        type: 'runtime',
+        message: event.message,
+        filename: event.filename,
+        lineno: event.lineno,
+        colno: event.colno,
+        stack: event.error?.stack
+    });
+});
+window.addEventListener('unhandledrejection', (event) => {
+    showError({
+        type: 'runtime',
+        message: `Unhandled Promise Rejection: ${event.reason}`,
+        stack: event.reason?.stack
+    });
+});

package/dist/runtime/error-overlay.d.ts

@@ -0,0 +1,15 @@
+export declare class ErrorOverlay extends HTMLElement {
+    root: ShadowRoot;
+    private _errors;
+    private _activeTab;
+    constructor();
+    connectedCallback(): void;
+    setupKeyboard(): void;
+    set errors(errors: any[]);
+    dismiss(): void;
+    openInEditor(file: string, line?: number, col?: number): void;
+    render(): void;
+    switchTab(tab: 'build' | 'runtime'): void;
+    renderError(error: any): string;
+    formatStack(stack: string): string;
+}