@nitronjs/framework 0.3.1 → 0.3.2

package/lib/Build/FileAnalyzer.js

@@ -94,7 +94,16 @@ class FileAnalyzer {
         const imported = new Set();
         const importedBy = new Map();
 
-        for (const file of files) {
+        // Start with .tsx files, then follow imports into .ts files (barrel exports, utils, types)
+        // so the importedBy chain stays complete across .ts intermediaries.
+        const queue = [...files];
+        let i = 0;
+
+        while (i < queue.length) {
+            const file = queue[i++];
+
+            if (graph.has(file)) continue;
+
             const meta = this.analyzeFile(file);
             graph.set(file, meta);
 
@@ -108,6 +117,12 @@ class FileAnalyzer {
                         importedBy.set(resolvedPath, []);
                     }
                     importedBy.get(resolvedPath).push(file);
+
+                    // If the resolved file is .ts (not .tsx) and not yet in graph, queue it
+                    // so its own imports get tracked in the dependency chain.
+                    if (resolvedPath.endsWith(".ts") && !graph.has(resolvedPath)) {
+                        queue.push(resolvedPath);
+                    }
                 }
             }
         }
@@ -215,7 +230,10 @@ class FileAnalyzer {
             JSXFragment: () => { meta.jsx = true; }
         });
 
-        if (meta.needsClient && !meta.isClient) {
+        // Only enforce "use client" requirement on .tsx files.
+        // .ts files (hooks, utils) are pure logic modules — they don't define components
+        // and are safe to import from either server or client code.
+        if (meta.needsClient && !meta.isClient && filePath.endsWith(".tsx")) {
             throw this.#createError('Missing "use client"', {
                 File: path.relative(Paths.project, filePath),
                 Fix: 'Add "use client" at top'
@@ -234,7 +252,15 @@ class FileAnalyzer {
     }
 
     #extractNamedExports(path, meta) {
-        const declaration = path.node.declaration;
+        const node = path.node;
+
+        // Re-exports: export { X } from './Y' — track the source as an import
+        // so the dependency graph stays complete through barrel files.
+        if (node.source && node.source.value && node.source.value.startsWith(".")) {
+            meta.imports.add(node.source.value);
+        }
+
+        const declaration = node.declaration;
 
         if (declaration?.type === "VariableDeclaration") {
             for (const decl of declaration.declarations) {
@@ -344,7 +370,9 @@ class FileAnalyzer {
                 const resolvedPath = this.resolveImport(filePath, importPath);
                 const resolvedMeta = graph.get(resolvedPath);
 
-                if (resolvedMeta && !resolvedMeta.isClient) {
+                // .ts files (hooks, utils, types) are pure logic — no server/client boundary.
+                // Only .tsx files with JSX can be server components that violate the boundary.
+                if (resolvedMeta && !resolvedMeta.isClient && resolvedPath.endsWith(".tsx")) {
                     throw this.#createError("Boundary Violation", {
                         Client: relativePath(filePath),
                         Server: relativePath(resolvedPath),

package/lib/Build/Manager.js

@@ -258,16 +258,30 @@ class Builder {
             ...(frameworkBundle.changedFiles || [])
         ]);
 
-        // Include changed client component sources so their hydration bundles rebuild
+        // Include changed client component sources so their hydration bundles rebuild.
+        // Also include any client components that transitively import the changed file,
+        // because esbuild bundles all imports into each client chunk. If a dependency
+        // changes, every client chunk that bundles it must be rebuilt too.
         for (const bundle of [userBundle, frameworkBundle]) {
-            if (!bundle?.changedSources) continue;
+            if (!bundle?.changedSources || !bundle.meta) continue;
 
             for (const file of bundle.changedSources) {
-                const fileMeta = bundle.meta?.get(file);
+                const fileMeta = bundle.meta.get(file);
                 if (fileMeta?.isClient) changedViews.add(file);
+
+                const dependents = this.#getTransitiveDependents(file, bundle.importedBy || new Map());
+
+                for (const dep of dependents) {
+                    const depMeta = bundle.meta.get(dep);
+                    if (depMeta?.isClient) changedViews.add(dep);
+                }
             }
         }
 
+        if (changedViews.size > 0) {
+            this.#cache.viewsChanged = true;
+        }
+
         for (const file of changedViews) {
             this.#changedFiles.add(file);
         }
@@ -366,13 +380,13 @@ class Builder {
 
     async #buildViewBundle(namespace, srcDir, outDir) {
         if (!fs.existsSync(srcDir)) {
-            return { entries: [], layouts: [], meta: new Map(), srcDir, namespace, changedFiles: [], changedSources: new Set() };
+            return { entries: [], layouts: [], meta: new Map(), importedBy: new Map(), srcDir, namespace, changedFiles: [], changedSources: new Set() };
         }
 
         const { entries, layouts, meta, importedBy } = this.#analyzer.discoverEntries(srcDir);
 
         if (!entries.length && !layouts.length) {
-            return { entries: [], layouts: [], meta: new Map(), srcDir, namespace, changedFiles: [], changedSources: new Set() };
+            return { entries: [], layouts: [], meta: new Map(), importedBy: new Map(), srcDir, namespace, changedFiles: [], changedSources: new Set() };
         }
 
         // Pre-scan: compute effective prop usage for server→client boundary filtering.
@@ -435,7 +449,7 @@ class Builder {
 
         this.#stats[namespace === "user" ? "user" : "framework"] = entries.length;
 
-        return { entries, layouts, meta, srcDir, namespace, changedFiles, changedSources };
+        return { entries, layouts, meta, importedBy, srcDir, namespace, changedFiles, changedSources };
     }
 
     async #postProcessMeta(entries, srcDir, outDir) {
@@ -737,7 +751,8 @@ class Builder {
 
             this.#manifest[key] = {
                 css: cssFiles,
-                isLayout: true
+                isLayout: true,
+                translationKeys: this.#collectTranslationKeys(layout, meta)
             };
         }
     }

package/lib/Build/PropUsageAnalyzer.js

@@ -634,6 +634,7 @@ function trackVariableAccess(varName, funcPath, bodyStart) {
     let usedAsWhole = false;
     const chains = [];
     const arrayIterations = [];
+    const derivedArrayVars = [];
 
     funcPath.traverse({
         Identifier(idPath) {
@@ -690,6 +691,17 @@ function trackVariableAccess(varName, funcPath, bodyStart) {
 
                         if (callbacks.length > 0) {
                             arrayIterations.push({ prefixChain, callbacks });
+
+                            const lastCall = getLastChainedCall(outermost.parentPath);
+
+                            if (lastCall.parentPath.isVariableDeclarator() &&
+                                lastCall.parentPath.node.id.type === "Identifier") {
+                                derivedArrayVars.push({
+                                    derivedName: lastCall.parentPath.node.id.name,
+                                    prefixChain
+                                });
+                            }
+
                             return;
                         }
 
@@ -710,7 +722,6 @@ function trackVariableAccess(varName, funcPath, bodyStart) {
                 return;
             }
 
-            // Check direct for...of: for (const item of varName)
             if (idPath.parentPath.isForOfStatement() &&
                 idPath.parentPath.node.right === idPath.node) {
                 const loopVar = extractForOfVariable(idPath.parentPath.node);
@@ -721,19 +732,26 @@ function trackVariableAccess(varName, funcPath, bodyStart) {
                 }
             }
 
-            // Guard/truthy checks (isAdmin && ..., isAdmin ? ... : ...) need the
-            // value itself but not its sub-properties. Mark as whole usage so
-            // boolean props are kept in the filtered output.
             if (isGuardCheck(idPath)) {
                 usedAsWhole = true;
                 return;
             }
 
-            // Used directly (as argument, JSX attribute value, assignment, etc.)
             usedAsWhole = true;
         }
     });
 
+    for (const derived of derivedArrayVars) {
+        const derivedIters = collectDerivedArrayUsage(derived.derivedName, funcPath, bodyStart);
+
+        for (const iter of derivedIters) {
+            arrayIterations.push({
+                prefixChain: derived.prefixChain,
+                ...iter
+            });
+        }
+    }
+
     if (usedAsWhole) return true;
     if (chains.length === 0 && arrayIterations.length === 0) return false;
 
@@ -919,12 +937,83 @@ function mergeArrayUsage(tree, prefixChain, elementUsage) {
     }
 }
 
-/**
- * Collects property names from a MemberExpression chain.
- * admin.mfa.status → ["mfa", "status"]
- * @param {import("@babel/traverse").NodePath} memberPath
- * @returns {string[]}
- */
+function getLastChainedCall(callExprPath) {
+    let current = callExprPath;
+
+    while (true) {
+        const parent = current.parentPath;
+
+        if (!parent || (!parent.isMemberExpression() && !parent.isOptionalMemberExpression())) break;
+        if (parent.node.object !== current.node || parent.node.computed) break;
+
+        const method = parent.node.property?.name;
+        const gp = parent.parentPath;
+
+        if ((gp.isCallExpression() || gp.isOptionalCallExpression()) &&
+            gp.node.callee === parent.node &&
+            ARRAY_METHODS.has(method)) {
+            current = gp;
+        }
+        else {
+            break;
+        }
+    }
+
+    return current;
+}
+
+function collectDerivedArrayUsage(derivedName, funcPath, bodyStart) {
+    const iterations = [];
+
+    funcPath.traverse({
+        Identifier(idPath) {
+            if (idPath.node.start < bodyStart) return;
+            if (idPath.node.name !== derivedName) return;
+            if (isInTypeAnnotation(idPath)) return;
+
+            if (idPath.parentPath.isObjectProperty() &&
+                idPath.parentPath.node.key === idPath.node &&
+                !idPath.parentPath.node.computed) return;
+
+            if (idPath.parentPath.isVariableDeclarator() &&
+                idPath.parentPath.node.id === idPath.node) return;
+
+            const isMember = idPath.parentPath.isMemberExpression() || idPath.parentPath.isOptionalMemberExpression();
+
+            if (isMember &&
+                idPath.parentPath.node.object === idPath.node &&
+                !idPath.parentPath.node.computed) {
+
+                const propName = idPath.parentPath.node.property?.name;
+                const grandParent = idPath.parentPath.parentPath;
+                const isCall = (grandParent.isCallExpression() || grandParent.isOptionalCallExpression()) &&
+                               grandParent.node.callee === idPath.parentPath.node;
+
+                if (isCall && ARRAY_METHODS.has(propName)) {
+                    const callbacks = collectArrayCallbacks(grandParent, propName);
+
+                    if (callbacks.length > 0) {
+                        iterations.push({ callbacks });
+                    }
+                }
+
+                return;
+            }
+
+            if (idPath.parentPath.isForOfStatement() &&
+                idPath.parentPath.node.right === idPath.node) {
+                const loopVar = extractForOfVariable(idPath.parentPath.node);
+
+                if (loopVar) {
+                    iterations.push({ loopVar, scopePath: idPath.parentPath });
+                }
+            }
+        }
+    });
+
+    return iterations;
+}
+
 function collectMemberChain(memberPath) {
     const chain = [];
     let current = memberPath;
@@ -976,6 +1065,7 @@ function analyzePropsIdentifier(propsName, funcPath) {
     let usedAsWhole = false;
     const chains = [];
     const arrayIterations = [];
+    const derivedArrayVars = [];
     const bodyStart = funcPath.node.body?.start ?? 0;
 
     funcPath.traverse({
@@ -1013,6 +1103,17 @@ function analyzePropsIdentifier(propsName, funcPath) {
 
                         if (callbacks.length > 0) {
                             arrayIterations.push({ prefixChain, callbacks });
+
+                            const lastCall = getLastChainedCall(outermost.parentPath);
+
+                            if (lastCall.parentPath.isVariableDeclarator() &&
+                                lastCall.parentPath.node.id.type === "Identifier") {
+                                derivedArrayVars.push({
+                                    derivedName: lastCall.parentPath.node.id.name,
+                                    prefixChain
+                                });
+                            }
+
                             return;
                         }
 
@@ -1033,11 +1134,21 @@ function analyzePropsIdentifier(propsName, funcPath) {
                 return;
             }
 
-            // props used as a whole (destructured in body, passed as arg, etc.)
             usedAsWhole = true;
         }
     });
 
+    for (const derived of derivedArrayVars) {
+        const derivedIters = collectDerivedArrayUsage(derived.derivedName, funcPath, bodyStart);
+
+        for (const iter of derivedIters) {
+            arrayIterations.push({
+                prefixChain: derived.prefixChain,
+                ...iter
+            });
+        }
+    }
+
     if (usedAsWhole) return null;
     if (chains.length === 0 && arrayIterations.length === 0) return {};
 

package/lib/Console/Commands/BuildCommand.js

@@ -21,6 +21,6 @@ if (isMain) {
     const onlyArg = process.argv.find(arg => arg.startsWith("--only="));
     const only = onlyArg?.split("=")[1] || null;
     Build(only, false) // Production build
-        .then(success => process.exit(success ? 0 : 1))
-        .catch(() => process.exit(1));
+        .then(success => { process.exitCode = success ? 0 : 1; })
+        .catch(() => { process.exitCode = 1; });
 }

package/lib/Console/Commands/DevCommand.js

@@ -150,12 +150,21 @@ class DevServer {
             this.#debounce.build = setTimeout(async () => {
                 const r = await this.#build();
                 if (r.success) {
-                    const changeType = detectChangeType(filePath);
-                    this.#send("change", {
-                        changeType,
-                        cssChanged: r.cssChanged || false,
-                        file: rel
-                    });
+                    // When client component JS chunks are rebuilt, the browser
+                    // still has the old JS modules loaded in memory. RSC refetch
+                    // only updates the React tree data, not the actual JS code.
+                    // A full page reload is needed to load the new JS chunks.
+                    if (r.viewsChanged) {
+                        this.#send("reload", { reason: "Client component changed" });
+                    }
+                    else {
+                        const changeType = detectChangeType(filePath);
+                        this.#send("change", {
+                            changeType,
+                            cssChanged: r.cssChanged || false,
+                            file: rel
+                        });
+                    }
                 }
             }, 100);
             return;
@@ -224,9 +233,9 @@ class DevServer {
 
         const exit = async () => {
             console.log();
-            watcher.close();
+            await watcher.close();
             await this.#stop();
-            process.exit(0);
+            process.exitCode = 0;
         };
 
         process.on("SIGINT", exit);
@@ -245,5 +254,5 @@ export default async function Dev() {
 }
 
 if (process.argv[1]?.endsWith("DevCommand.js")) {
-    Dev().catch(e => { console.error(e); process.exit(1); });
+    Dev().catch(e => { console.error(e); process.exitCode = 1; });
 }

package/lib/Console/Commands/MakeCommand.js

@@ -123,9 +123,9 @@ const isMain = process.argv[1]?.endsWith("MakeCommand.js");
 if (isMain) {
     const [, , type, rawName] = process.argv;
     make(type, rawName)
-        .then(success => process.exit(success ? 0 : 1))
+        .then(success => { process.exitCode = success ? 0 : 1; })
         .catch(err => {
             console.error(err);
-            process.exit(1);
+            process.exitCode = 1;
         });
 }

package/lib/Console/Commands/MigrateCommand.js

@@ -50,7 +50,7 @@ if (isMain) {
     const shouldSeed = args.includes("--seed");
 
     migrate({ seed: shouldSeed })
-        .then(success => process.exit(success ? 0 : 1))
+        .then(success => { process.exit(success ? 0 : 1); })
         .catch(err => {
             console.error(err);
             process.exit(1);

package/lib/Console/Commands/MigrateFreshCommand.js

@@ -68,7 +68,7 @@ if (isMain) {
     const shouldSeed = args.includes("--seed");
 
     migrateFresh({ seed: shouldSeed })
-        .then(success => process.exit(success ? 0 : 1))
+        .then(success => { process.exit(success ? 0 : 1); })
         .catch(err => {
             console.error(err);
             process.exit(1);

package/lib/Console/Commands/MigrateRollbackCommand.js

@@ -50,7 +50,7 @@ if (isMain) {
     const all = args.includes('--all');
 
     rollback({ step, all })
-        .then(success => process.exit(success ? 0 : 1))
+        .then(success => { process.exit(success ? 0 : 1); })
         .catch(err => {
             console.error(err);
             process.exit(1);

package/lib/Console/Commands/MigrateStatusCommand.js

@@ -36,7 +36,7 @@ export default async function status() {
 const isMain = process.argv[1]?.endsWith("MigrateStatusCommand.js");
 if (isMain) {
     status()
-        .then(success => process.exit(success ? 0 : 1))
+        .then(success => { process.exit(success ? 0 : 1); })
         .catch(err => {
             console.error(err);
             process.exit(1);

package/lib/Console/Commands/SeedCommand.js

@@ -37,7 +37,7 @@ if (isMain) {
     const seederName = args.find(a => !a.startsWith('--')) || null;
 
     seed(seederName)
-        .then(success => process.exit(success ? 0 : 1))
+        .then(success => { process.exit(success ? 0 : 1); })
         .catch(err => {
             console.error(err);
             process.exit(1);

package/lib/Console/Commands/StartCommand.js

@@ -14,7 +14,8 @@ export default async function Start() {
 
         if (!success) {
             Output.error("Build failed. Cannot start server.");
-            process.exit(1);
+            process.exitCode = 1;
+            return;
         }
     }
 

package/lib/Console/Commands/StorageLinkCommand.js

@@ -1,10 +1,11 @@
-import fs from "fs";
+import fs from "fs/promises";
 import path from "path";
 import os from "os";
 import Output from "../Output.js";
 
 /**
  * Creates a symbolic link from storage/app/public to public/storage.
+ * On Windows, uses "junction" type because it doesn't require admin privileges.
  * @returns {Promise<boolean>}
  */
 export default async function storageLink() {
@@ -12,35 +13,23 @@ export default async function storageLink() {
     const target = path.join(process.cwd(), "public", "storage");
     const linkType = os.platform() === "win32" ? "junction" : "dir";
 
-    return new Promise((resolve, reject) => {
-        fs.symlink(source, target, linkType, (err) => {
-            if (err) {
-                if (err.code === "EEXIST") {
-                    Output.warn("Symbolic link already exists");
-                    Output.dim(`  ${source} → ${target}`);
-                    Output.newline();
-                    resolve(true);
-                }
-                else {
-                    Output.error("Failed to create symbolic link");
-                    Output.dim(`  ${err.message}`);
-                    reject(err);
-                }
-            }
-            else {
-                Output.success("Symbolic link created");
-                Output.dim(`  ${source} → ${target}`);
-                Output.newline();
-                resolve(true);
-            }
-        });
-    });
-}
+    try {
+        await fs.symlink(source, target, linkType);
+        Output.success("Symbolic link created");
+        Output.dim(`  ${source} → ${target}`);
+        Output.newline();
+        return true;
+    }
+    catch (err) {
+        if (err.code === "EEXIST") {
+            Output.warn("Symbolic link already exists");
+            Output.dim(`  ${source} → ${target}`);
+            Output.newline();
+            return true;
+        }
 
-// Auto-run when called directly
-const isMain = process.argv[1]?.endsWith("StorageLinkCommand.js");
-if (isMain) {
-    storageLink()
-        .then(() => process.exit(0))
-        .catch(() => process.exit(1));
-}
+        Output.error("Failed to create symbolic link");
+        Output.dim(`  ${err.message}`);
+        return false;
+    }
+}

package/lib/Console/Stubs/rsc-consumer.tsx

@@ -39,7 +39,7 @@ function navigateWithPayload(payload: string) {
     rsc.root.render(React.createElement(Root));
 }
 
-function mount() {
+async function mount() {
     const payload = window.__NITRON_FLIGHT__;
 
     if (!payload) return;
@@ -47,6 +47,22 @@ function mount() {
     const stream = payloadToStream(payload);
     const rscResponse = createFromReadableStream(stream);
 
+    // Wait for the RSC response to fully resolve before hydrating.
+    //
+    // Without this, hydrateRoot starts rendering AFTER the ReadableStream
+    // has already closed. React then tries to look up component chunks
+    // that no longer exist in the stream, causing "Connection closed" errors.
+    //
+    // By awaiting here, all component modules are loaded and ready BEFORE
+    // React starts rendering. This prevents the race condition entirely.
+    try {
+        await rscResponse;
+    }
+    catch (err) {
+        console.error('[rsc-consumer] RSC response failed to resolve:', err);
+        return;
+    }
+
     function Root(): React.ReactNode {
         return React.use(rscResponse) as React.ReactNode;
     }

package/lib/Console/Stubs/vendor-dev.tsx

@@ -86,3 +86,34 @@ Object.assign(window, {
     __webpack_get_script_filename__: webpackRequire.u
 });
 
+// Client-side translation function
+// Reads translations from window.__NITRON_TRANSLATIONS__ injected by the server
+(globalThis as any).__ = function(key: string, params?: Record<string, any>): string {
+    const translations = (window as any).__NITRON_TRANSLATIONS__;
+
+    if (!translations) return key;
+
+    let value = translations[key];
+
+    if (value === undefined) return key;
+
+    value = String(value);
+
+    // Replace :param placeholders with actual values
+    if (params && typeof params === "object") {
+        const keys = Object.keys(params);
+
+        for (let i = 0; i < keys.length; i++) {
+            const v = params[keys[i]];
+
+            if (v !== null && v !== undefined) {
+                value = value.split(":" + keys[i]).join(String(v));
+            }
+        }
+    }
+
+    return value;
+};
+
+(globalThis as any).lang = (globalThis as any).__;
+

package/lib/Console/Stubs/vendor.tsx

@@ -68,3 +68,34 @@ Object.assign(window, {
     __webpack_chunk_load__: webpackChunkLoad,
     __webpack_get_script_filename__: webpackRequire.u
 });
+
+// Client-side translation function
+// Reads translations from window.__NITRON_TRANSLATIONS__ injected by the server
+(globalThis as any).__ = function(key: string, params?: Record<string, any>): string {
+    const translations = (window as any).__NITRON_TRANSLATIONS__;
+
+    if (!translations) return key;
+
+    let value = translations[key];
+
+    if (value === undefined) return key;
+
+    value = String(value);
+
+    // Replace :param placeholders with actual values
+    if (params && typeof params === "object") {
+        const keys = Object.keys(params);
+
+        for (let i = 0; i < keys.length; i++) {
+            const v = params[keys[i]];
+
+            if (v !== null && v !== undefined) {
+                value = value.split(":" + keys[i]).join(String(v));
+            }
+        }
+    }
+
+    return value;
+};
+
+(globalThis as any).lang = (globalThis as any).__;