@fastang/core 0.1.0-alpha.3 → 0.1.0-alpha.5

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 0.1.0-alpha.5
+
+- Default development Fastify/Vite logging to warn, retain the startup address and allow FASTANG_LOG_LEVEL overrides. Suppress successful dev check summaries with check --quiet.
+
+- Preserve relative dependency symlinks in Vercel functions for pnpm installations.
+
+## 0.1.0-alpha.4
+
+- Add source-only `fastang check` diagnostics for API route/contract correspondence, with tsconfig resolution, JSON and strict mode.
+- Run checks before builds and development restarts; share diagnostics with the Vite overlay.
+
+- Bound development server shutdown to three seconds before forced termination.
+- Use English for framework diagnostics.
+
 ## 0.1.0-alpha.3
 
 - Coordinate the standalone CLI release and starter while preserving runtime APIs.

package/README.md

@@ -1,7 +1,7 @@
 # @fastang/core
 
 Experimental FastAng runtime and tooling for Angular + Fastify applications.
-Version 0.1.0-alpha.2 is an experimental alpha. Public APIs may change between alpha releases.
+Version 0.1.0-alpha.5 is an experimental alpha. Public APIs may change between alpha releases.
 
 The package contains compiled JavaScript and TypeScript declarations. Angular,
 Fastify, Vite and the Angular compiler are explicit peer dependencies so the app
@@ -82,7 +82,62 @@ See the [public API and support reference](https://fastang.dev/en/docs/reference
 ## Standalone CLI
 
 Project creation and upgrades belong to the separate lightweight `@fastang/cli`
-package introduced in alpha.3. Core provides `dev`, `build`, `generate` and `routes`.
+package introduced in alpha.3. Core provides `dev`, `build`, `generate`, `routes` and (from alpha.4) `check`.
 The global CLI forwards these commands to the app's installed core.
 
 See [CLI behavior and limitations](../../docs/cli.md).
+
+## Static route checks
+
+From `0.1.0-alpha.4`, FastAng includes a route/contract diagnostic command:
+
+```sh
+npx fastang check
+npx fastang check --json
+npx fastang check --strict --project tsconfig.node.json
+```
+
+The checker defaults to `tsconfig.node.json`, falling back to `tsconfig.json`.
+It uses TypeScript module resolution, including inherited compiler settings,
+`paths`, aliases and re-exports. It starts from file-based API routes and checks
+only the contract actually passed to `defineContractRoute`; unused contracts
+are not treated as missing routes. It never imports application modules, loads
+FastAng/Vite configuration, emits files or connects to application services.
+
+Literal strings, const references, object literals and resolvable spreads are
+supported. Function calls that construct contracts, mutable variables, wrappers
+and unresolved imports produce `FA1003` (unverified), rather than a successful
+verification. `--strict` makes these warnings errors. A known method/path mismatch
+is `FA1002`; configuration/syntax errors are `FA1000`, and route discovery errors
+are `FA1001`. Errors exit with code 1. JSON output has `schemaVersion: 1`, counts
+and diagnostics with source positions and a related contract location for
+mismatches. `defineApiRoute` needs no contract correspondence check.
+
+This is a source-convention check, not general constant evaluation or a replacement
+for TypeScript/Angular checks. Keep method/path definitions declarative; mutations
+or side effects elsewhere are not evaluated. Resolving a TS alias here does not
+configure runtime aliases. Registration-time validation remains in place.
+
+`fastang build` checks before loading application configuration or clearing build
+output. The Vite plugin reuses the checker and reports errors in its terminal and
+overlay on route/contract edits; fixing them triggers a full reload. `fastang dev`
+checks before restarting the backend and keeps an existing server during an invalid
+edit. The standalone CLI delegates `check` to the app's installed core: both need
+a release containing this command. Use `0.1.0-alpha.4` or later for both packages.
+
+## Development logging
+
+From `0.1.0-alpha.5`, development defaults to `warn` for both Fastify and Vite during `fastang dev`.
+The listening address remains visible. Routine HTTP request/completion logs and
+successful route-check summaries are omitted; warnings, errors and failed checks
+remain visible. Production logger configuration is unchanged.
+
+Set `FASTANG_LOG_LEVEL=info` or `FASTANG_LOG_LEVEL=debug` in the process environment
+when investigating requests. Accepted values are `trace`, `debug`, `info`, `warn`,
+`error`, `fatal` and `silent`. Vite maps trace/debug to info and fatal to error.
+This controls framework loggers, not application `console.log` calls or package
+manager output. The startup address is retained even with `silent`.
+
+`fastang check --quiet` suppresses only a successful text summary; diagnostics
+still print, and `--json` always returns the JSON report. The dev supervisor uses
+this option for checks before backend restarts. These options are available from `0.1.0-alpha.5`.

package/dist/adapters/vercel.js

@@ -1,5 +1,5 @@
-import { copyFile, mkdir, readFile, rm, stat, writeFile } from 'node:fs/promises';
-import { dirname, resolve } from 'node:path';
+import { copyFile, mkdir, readFile, rm, stat, lstat, readlink, symlink, writeFile } from 'node:fs/promises';
+import { dirname, resolve, relative, isAbsolute } from 'node:path';
 import { createRequire } from 'node:module';
 import { nodeFileTrace } from '@vercel/nft';
 import { staticFile } from "../server.js";
@@ -15,7 +15,22 @@ export async function buildVercelOutput(plan, root = process.cwd()) {
     await rm(output, { recursive: true, force: true });
     const copy = async (file, destination) => {
         await mkdir(dirname(destination), { recursive: true });
-        await copyFile(resolve(root, file), destination);
+        const source = resolve(root, file);
+        const info = await lstat(source);
+        if (info.isSymbolicLink()) {
+            const target = await readlink(source);
+            const sourceTarget = relative(root, resolve(dirname(source), target));
+            if (isAbsolute(target) || sourceTarget === '..' || sourceTarget.startsWith('../') || sourceTarget.startsWith('..\\'))
+                throw new Error(`Dependency symlink outside project: ${file}`);
+            const directory = (await stat(source)).isDirectory();
+            if (directory)
+                await mkdir(resolve(dirname(destination), target), { recursive: true });
+            await symlink(target, destination, directory ? 'dir' : 'file');
+        }
+        else if (info.isDirectory())
+            await mkdir(destination, { recursive: true });
+        else
+            await copyFile(source, destination);
     };
     const { cp } = await import('node:fs/promises');
     await cp(resolve(root, 'dist/client/assets'), resolve(output, 'static/assets'), { recursive: true });
@@ -39,11 +54,16 @@ export async function buildVercelOutput(plan, root = process.cwd()) {
         traces.set(entryFile, trace);
         for (const warning of trace.warnings)
             console.warn(`[vercel:${name}] ${warning.message}`);
-        for (const file of trace.fileList) {
+        const files = await Promise.all([...trace.fileList].map(async (file) => {
             if (file.startsWith('../') || file.startsWith('/'))
                 throw new Error(`Dependency outside project: ${file}`);
+            return { file, link: (await lstat(resolve(root, file))).isSymbolicLink() };
+        }));
+        // pnpm exposes dependencies through relative directory symlinks. Keep that
+        // topology in the function, creating links before copying traced files.
+        files.sort((a, b) => Number(b.link) - Number(a.link) || a.file.length - b.file.length);
+        for (const { file } of files)
             await copy(file, resolve(directory, file));
-        }
         if (kind === 'ssr')
             await copy('dist/client/index.html', resolve(directory, dirname(entryFile), '../client/index.html'));
         await mkdir(directory, { recursive: true });

package/dist/check.d.ts

@@ -0,0 +1,29 @@
+export interface CheckDiagnostic {
+    code: string;
+    severity: 'error' | 'warning';
+    message: string;
+    file?: string;
+    line?: number;
+    column?: number;
+    contract?: {
+        file: string;
+        line: number;
+        column: number;
+    };
+}
+export interface CheckResult {
+    schemaVersion: 1;
+    project: string;
+    routes: number;
+    verified: number;
+    diagnostics: CheckDiagnostic[];
+}
+export interface CheckOptions {
+    root?: string;
+    project?: string;
+    strict?: boolean;
+    onFiles?: (files: string[]) => void;
+}
+/** Analyze source only. No application imports, config execution, generation or emit. */
+export declare function checkRoutes(options?: CheckOptions): Promise<CheckResult>;
+export declare function formatCheck(result: CheckResult): string;

package/dist/check.js

@@ -0,0 +1,159 @@
+import ts from 'typescript';
+import { existsSync } from 'node:fs';
+import { basename, relative, resolve } from 'node:path';
+import { discover } from "./routes.js";
+/** Analyze source only. No application imports, config execution, generation or emit. */
+export async function checkRoutes(options = {}) {
+    const root = resolve(options.root ?? process.cwd());
+    const project = resolve(root, options.project ?? (existsSync(resolve(root, 'tsconfig.node.json')) ? 'tsconfig.node.json' : 'tsconfig.json'));
+    const result = { schemaVersion: 1, project: relative(root, project).replaceAll('\\', '/'), routes: 0, verified: 0, diagnostics: [] };
+    const fileName = (file) => relative(root, file).replaceAll('\\', '/');
+    const position = (node) => {
+        const source = node.getSourceFile();
+        const { line, character } = source.getLineAndCharacterOfPosition(node.getStart());
+        return { file: fileName(source.fileName), line: line + 1, column: character + 1 };
+    };
+    const configError = (error) => {
+        const location = error.file && error.start !== undefined ? error.file.getLineAndCharacterOfPosition(error.start) : undefined;
+        result.diagnostics.push({ code: 'FA1000', severity: 'error', message: ts.flattenDiagnosticMessageText(error.messageText, '\n'), ...(error.file ? { file: fileName(error.file.fileName) } : {}), ...(location ? { line: location.line + 1, column: location.character + 1 } : {}) });
+    };
+    const config = ts.readConfigFile(project, ts.sys.readFile);
+    if (config.error) {
+        configError(config.error);
+        return result;
+    }
+    const parsed = ts.parseJsonConfigFileContent(config.config, ts.sys, resolve(project, '..'), undefined, project);
+    if (parsed.errors.length) {
+        parsed.errors.forEach(configError);
+        return result;
+    }
+    let routes;
+    try {
+        routes = await discover(resolve(root, 'src/server/api'), 'api');
+    }
+    catch (error) {
+        result.diagnostics.push({ code: 'FA1001', severity: 'error', message: String(error instanceof Error ? error.message : error) });
+        return result;
+    }
+    result.routes = routes.length;
+    const program = ts.createProgram({ rootNames: [...new Set([...parsed.fileNames, ...routes.map(route => resolve(root, 'src/server/api', route.file))])], options: { ...parsed.options, noEmit: true } });
+    options.onFiles?.(program.getSourceFiles().filter(file => !file.isDeclarationFile && !file.fileName.replaceAll('\\', '/').includes('/node_modules/')).map(file => file.fileName));
+    const checker = program.getTypeChecker();
+    function symbol(node) {
+        const value = checker.getSymbolAtLocation(node);
+        return value && value.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(value) : value;
+    }
+    function unwrap(node) {
+        while (ts.isParenthesizedExpression(node) || ts.isAsExpression(node) || ts.isTypeAssertionExpression(node) || ts.isSatisfiesExpression(node) || ts.isNonNullExpression(node))
+            node = node.expression;
+        return node;
+    }
+    function value(node, seen = new Set()) {
+        if (!node || seen.has(node) || seen.size > 100)
+            return undefined;
+        seen.add(node);
+        node = unwrap(node);
+        if (ts.isIdentifier(node) || ts.isPropertyAccessExpression(node)) {
+            const declaration = symbol(ts.isPropertyAccessExpression(node) ? node.name : node)?.valueDeclaration;
+            if (declaration && ts.isVariableDeclaration(declaration) && declaration.parent.flags & ts.NodeFlags.Const)
+                return value(declaration.initializer, seen);
+            if (declaration && ts.isExportAssignment(declaration))
+                return value(declaration.expression, seen);
+            if (declaration && ts.isPropertyAssignment(declaration))
+                return value(declaration.initializer, seen);
+            if (ts.isPropertyAccessExpression(node))
+                return property(value(node.expression, seen), node.name.text, seen);
+            return undefined;
+        }
+        return node;
+    }
+    function property(node, key, seen = new Set()) {
+        if (!node || !ts.isObjectLiteralExpression(node))
+            return undefined;
+        for (const field of [...node.properties].reverse()) {
+            if (ts.isSpreadAssignment(field)) {
+                const spread = value(field.expression, new Set(seen));
+                if (!spread || !ts.isObjectLiteralExpression(spread))
+                    return undefined;
+                const found = property(spread, key, new Set(seen));
+                if (found)
+                    return found;
+                // An unresolved nested spread could override earlier fields.
+                if (spread.properties.some(field => ts.isSpreadAssignment(field) || field.name && (ts.isComputedPropertyName(field.name) || (ts.isIdentifier(field.name) || ts.isStringLiteral(field.name)) && field.name.text === key)))
+                    return undefined;
+            }
+            else {
+                if (field.name && ts.isComputedPropertyName(field.name))
+                    return undefined;
+                if (field.name && (ts.isIdentifier(field.name) || ts.isStringLiteral(field.name)) && field.name.text === key) {
+                    if (ts.isPropertyAssignment(field))
+                        return value(field.initializer, new Set(seen));
+                    if (ts.isShorthandPropertyAssignment(field)) {
+                        const declaration = checker.getShorthandAssignmentValueSymbol(field)?.valueDeclaration;
+                        return declaration && ts.isVariableDeclaration(declaration) && declaration.parent.flags & ts.NodeFlags.Const ? value(declaration.initializer, new Set(seen)) : undefined;
+                    }
+                    return undefined;
+                }
+            }
+        }
+        return undefined;
+    }
+    function apiCall(node, name, module) {
+        if (!node || !ts.isCallExpression(node))
+            return false;
+        const target = symbol(ts.isPropertyAccessExpression(node.expression) ? node.expression.name : node.expression);
+        return target?.name === name && !!target.declarations?.some(declaration => {
+            const path = declaration.getSourceFile().fileName.replaceAll('\\', '/');
+            return /\/(?:@fastang\/core|packages\/core)\/(?:src|dist)\//.test(path) && [module + '.ts', module + '.d.ts'].includes(basename(path));
+        });
+    }
+    const syntaxFiles = new Set();
+    for (const route of routes) {
+        const source = program.getSourceFile(resolve(root, 'src/server/api', route.file));
+        if (!source)
+            continue;
+        const expected = `${route.method} /api${route.path ? '/' + route.path : ''}`;
+        const module = checker.getSymbolAtLocation(source);
+        const exported = module && checker.getExportsOfModule(module).find(item => item.name === 'default');
+        const declaration = exported && (exported.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(exported) : exported).valueDeclaration;
+        const expression = declaration && (ts.isExportAssignment(declaration) ? value(declaration.expression) : ts.isVariableDeclaration(declaration) ? value(declaration.initializer) : declaration);
+        if (apiCall(expression, 'defineApiRoute', 'api'))
+            continue;
+        const warn = (message) => result.diagnostics.push({ code: 'FA1003', severity: options.strict ? 'error' : 'warning', message: `${expected}: ${message}`, ...position(declaration ?? source) });
+        if (!apiCall(expression, 'defineContractRoute', 'contract-route')) {
+            warn('Route export is not a statically resolvable defineContractRoute or defineApiRoute call; registration-time validation still applies to contract routes.');
+            continue;
+        }
+        const contract = value(expression.arguments[0]);
+        if (!apiCall(contract, 'defineApiContract', 'contracts')) {
+            warn('Contract is dynamic or unresolved; static correspondence cannot be verified.');
+            continue;
+        }
+        const definition = value(contract.arguments[0]);
+        const method = property(definition, 'method');
+        const path = property(definition, 'path');
+        if (!method || !path || !ts.isStringLiteralLike(method) || !ts.isStringLiteralLike(path)) {
+            warn('Contract method/path must resolve to string literals or const references.');
+            continue;
+        }
+        const actual = `${method.text} ${path.text}`;
+        if (actual !== expected)
+            result.diagnostics.push({ code: 'FA1002', severity: 'error', message: `File route ${expected}, contract ${actual}. Update the contract or rename/move the route file.`, ...position(expression.getSourceFile() === source ? expression : source), contract: position(contract) });
+        else
+            result.verified++;
+        syntaxFiles.add(contract.getSourceFile().fileName);
+    }
+    routes.forEach(route => syntaxFiles.add(resolve(root, 'src/server/api', route.file)));
+    for (const file of syntaxFiles) {
+        const source = program.getSourceFile(file);
+        if (source)
+            program.getSyntacticDiagnostics(source).forEach(configError);
+    }
+    result.diagnostics.sort((a, b) => (a.file ?? '').localeCompare(b.file ?? '') || (a.line ?? 0) - (b.line ?? 0) || a.code.localeCompare(b.code));
+    return result;
+}
+export function formatCheck(result) {
+    const lines = result.diagnostics.map(d => `${d.file ?? result.project}${d.line ? `:${d.line}:${d.column}` : ''} ${d.severity} ${d.code}: ${d.message}${d.contract ? `\n  Contract: ${d.contract.file}:${d.contract.line}:${d.contract.column}` : ''}`);
+    lines.push(`FastAng routes: ${result.verified} contracts verified, ${result.routes} API routes, ${result.diagnostics.filter(d => d.severity === 'error').length} errors, ${result.diagnostics.filter(d => d.severity === 'warning').length} warnings.`);
+    return lines.join('\n');
+}

package/dist/cli.js

@@ -3,6 +3,8 @@ const command = process.argv[2];
 try {
     if (command === 'generate')
         await (await import("./routes.js")).generate();
+    else if (command === 'check')
+        await import("./commands/check.js");
     else if (command === 'routes')
         await import("./commands/inspect-routes.js");
     else if (command === 'dev')
@@ -10,7 +12,7 @@ try {
     else if (command === 'build')
         await import("./commands/build.js");
     else if (!command || command === '--help' || command === '-h')
-        console.log('Usage: fastang <dev|generate|build|routes>\n  build [--vercel]\n  routes [--json]');
+        console.log('Usage: fastang <dev|generate|build|routes|check>\n  build [--vercel]\n  routes [--json]\n  check [--project tsconfig.node.json] [--json] [--strict] [--quiet]');
     else
         throw new Error(`Unknown command: ${command}`);
 }

package/dist/commands/build.js

@@ -14,6 +14,12 @@ import { prepareVercelPlan } from "../adapters/vercel-plan.js";
 import { buildVercelOutput } from "../adapters/vercel.js";
 import { staticFile } from "../static-path.js";
 import { loadFastangConfig } from "./load-config.js";
+const { checkRoutes, formatCheck } = await import("../check.js");
+const check = await checkRoutes();
+if (check.diagnostics.length)
+    console.log(formatCheck(check));
+if (check.diagnostics.some(diagnostic => diagnostic.severity === 'error'))
+    throw new Error('FastAng route check failed');
 const config = await loadFastangConfig('build');
 const vercel = process.argv.includes('--vercel');
 const paths = [...new Set(config.prerender)];

package/dist/commands/check.d.ts

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

package/dist/commands/check.js

@@ -0,0 +1,16 @@
+import { checkRoutes, formatCheck } from "../check.js";
+const args = process.argv.slice(3);
+let project;
+for (let index = 0; index < args.length; index++) {
+    if (args[index] === '--project' && args[index + 1] && !args[index + 1].startsWith('-'))
+        project = args[++index];
+    else if (!['--json', '--strict', '--quiet'].includes(args[index]))
+        throw new Error('Usage: fastang check [--project tsconfig.node.json] [--json] [--strict] [--quiet]');
+}
+const result = await checkRoutes({ project, strict: args.includes('--strict') });
+if (args.includes('--json'))
+    console.log(JSON.stringify(result, null, 2));
+else if (!args.includes('--quiet') || result.diagnostics.length)
+    console.log(formatCheck(result));
+if (result.diagnostics.some(diagnostic => diagnostic.severity === 'error'))
+    process.exitCode = 1;

package/dist/commands/dev-logging.d.ts

@@ -0,0 +1,10 @@
+import type { LogLevel } from 'vite';
+declare const levels: readonly ["trace", "debug", "info", "warn", "error", "fatal", "silent"];
+type Level = typeof levels[number];
+/** Development only: production servers keep their own logger configuration. */
+export declare function developmentLogging(value?: string | undefined): {
+    level: Level;
+    vite: LogLevel;
+    banner: boolean;
+};
+export {};

package/dist/commands/dev-logging.js

@@ -0,0 +1,13 @@
+const levels = ['trace', 'debug', 'info', 'warn', 'error', 'fatal', 'silent'];
+/** Development only: production servers keep their own logger configuration. */
+export function developmentLogging(value = process.env['FASTANG_LOG_LEVEL']) {
+    const level = value ?? 'warn';
+    if (!levels.includes(level))
+        throw new Error(`FASTANG_LOG_LEVEL must be one of: ${levels.join(', ')}`);
+    return {
+        level: level,
+        vite: ['trace', 'debug', 'info'].includes(level) ? 'info' : level === 'fatal' ? 'error' : level,
+        // Fastify already announces the address at info; preserve it at quieter levels.
+        banner: !['trace', 'debug', 'info'].includes(level),
+    };
+}

package/dist/commands/dev-server.js

@@ -6,16 +6,18 @@ import { listen } from "../listen.js";
 import { tsImport } from 'tsx/esm/api';
 import { resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
+import { developmentLogging } from "./dev-logging.js";
 import { loadFastangConfig } from "./load-config.js";
+const logging = developmentLogging();
 await loadFastangConfig('serve');
 const { configureServer } = await tsImport(pathToFileURL(resolve('src/server/plugins.ts')).href, import.meta.url);
 const { registerApi } = await tsImport(pathToFileURL(resolve('.fastang/api.ts')).href, import.meta.url);
 let vite;
 try {
     const app = await createServer({
-        logger: true, registerApi,
+        logger: { level: logging.level }, registerApi,
         async configure(server) {
-            vite = await createViteServer({ server: { middlewareMode: true, hmr: { server: server.server } }, appType: 'custom' });
+            vite = await createViteServer({ logLevel: logging.vite, server: { middlewareMode: true, hmr: { server: server.server } }, appType: 'custom' });
             server.addHook('onClose', async () => { await vite?.close(); });
             await server.register(middie);
             // Middie gestisce next(), risposte completate ed errori del middleware Connect.
@@ -36,6 +38,13 @@ try {
         },
     });
     await listen(app);
+    if (logging.banner) {
+        const address = app.server.address();
+        if (address && typeof address !== 'string') {
+            const host = address.family === 'IPv6' ? `[${address.address}]` : address.address;
+            console.log(`Server listening at http://${host}:${address.port}`);
+        }
+    }
 }
 catch (error) {
     await vite?.close();

package/dist/commands/dev.js

@@ -3,26 +3,27 @@ import { fileURLToPath } from 'node:url';
 import { watch } from 'node:fs';
 import { spawn } from 'node:child_process';
 import { once } from 'node:events';
+import { stopChild } from "./stop-child.js";
 let child;
 let stopping = false;
 let timer;
 let queue = Promise.resolve();
-async function stopChild() {
-    if (child && child.exitCode === null && child.signalCode === null) {
-        const exited = once(child, 'exit');
-        child.kill('SIGTERM');
-        await exited;
-    }
-}
 async function restart() {
-    await stopChild();
+    if (stopping)
+        return;
+    // Keep the previous server available for Vite diagnostics while an edit is invalid.
+    const checker = spawn(process.execPath, [fileURLToPath(new URL('../cli.js', import.meta.url)), 'check', '--quiet'], { stdio: 'inherit', env: process.env });
+    const [checked] = await once(checker, 'exit');
+    if (checked !== 0 || stopping)
+        return;
+    await stopChild(child);
     if (stopping)
         return;
     // Processo nuovo: anche le modifiche al generatore sono applicate al riavvio.
     const generator = spawn(process.execPath, [fileURLToPath(new URL('../cli.js', import.meta.url)), 'generate'], { stdio: 'inherit', env: process.env });
     const [code] = await once(generator, 'exit');
     if (code !== 0)
-        throw new Error('Generazione route fallita');
+        throw new Error('Route generation failed');
     child = spawn(process.execPath, [fileURLToPath(new URL('./dev-server.js', import.meta.url))], { stdio: 'inherit', env: process.env });
     child.on('error', (error) => { console.error(error); process.exitCode = 1; });
 }
@@ -33,14 +34,15 @@ function changed() {
     }, 150);
 }
 // Solo sorgenti backend e configurazione: i moduli temporanei di Vite non causano riavvii.
-const watchers = ['src/server', 'src/shared', 'vite.config.ts', 'fastang.config.ts'].filter(existsSync).map(path => watch(path, { recursive: true }, changed));
+const watchers = ['src/server', 'src/shared', 'vite.config.ts', 'fastang.config.ts', 'tsconfig.json', 'tsconfig.node.json'].filter(existsSync).map(path => watch(path, { recursive: true }, changed));
 async function shutdown() {
     stopping = true;
     clearTimeout(timer);
     watchers.forEach((watcher) => watcher.close());
     await queue;
-    await stopChild();
+    await stopChild(child);
 }
 process.once('SIGINT', shutdown);
 process.once('SIGTERM', shutdown);
-await restart();
+queue = restart();
+await queue;

package/dist/commands/stop-child.d.ts

@@ -0,0 +1,6 @@
+import type { ChildProcess } from 'node:child_process';
+/** Give application shutdown hooks time to finish, then bound the supervisor wait. */
+export declare function stopChild(child: ChildProcess | undefined, timeoutMs?: number, warn?: {
+    (...data: any[]): void;
+    (message?: any, ...optionalParams: any[]): void;
+}): Promise<void>;

package/dist/commands/stop-child.js

@@ -0,0 +1,22 @@
+/** Give application shutdown hooks time to finish, then bound the supervisor wait. */
+export async function stopChild(child, timeoutMs = 3000, warn = console.warn) {
+    if (!child || child.exitCode !== null || child.signalCode !== null)
+        return;
+    await new Promise((resolveStop, reject) => {
+        let timer;
+        const cleanup = () => {
+            clearTimeout(timer);
+            child.removeListener('exit', exited);
+            child.removeListener('error', failed);
+        };
+        const exited = () => { cleanup(); resolveStop(); };
+        const failed = (error) => { cleanup(); reject(error); };
+        child.once('exit', exited);
+        child.once('error', failed);
+        timer = setTimeout(() => {
+            warn(`Development server did not stop within ${timeoutMs}ms; forcing termination.`);
+            child.kill('SIGKILL');
+        }, timeoutMs);
+        child.kill('SIGTERM');
+    });
+}

package/dist/listen.js

@@ -4,7 +4,7 @@ export async function listen(app) {
     const port = Number(process.env['PORT'] ?? DEFAULT_PORT);
     const host = process.env['HOST'] ?? '127.0.0.1';
     if (!Number.isInteger(port) || port < 0 || port > 65535)
-        throw new Error('PORT deve essere una porta valida');
+        throw new Error('PORT must be a valid port');
     const shutdown = async () => {
         try {
             await app.close();

package/dist/redirect.js

@@ -1,13 +1,13 @@
 /** Solo destinazioni locali: gli header Host del client non decidono l'origine. */
 export function normalizeRedirectLocation(location) {
     if (!location.startsWith('/') || location.startsWith('//') || /[\\\u0000-\u0020\u007f]/.test(location)) {
-        throw new Error('Destinazione redirect non valida');
+        throw new Error('Invalid redirect destination');
     }
     const target = new URL(location, 'http://fastang.local');
     if (target.origin !== 'http://fastang.local')
-        throw new Error('Redirect esterno non consentito');
+        throw new Error('External redirects are not allowed');
     // La normalizzazione può trasformare /a/..//host in //host: ricontrolla l'output.
     if (target.pathname.startsWith('//'))
-        throw new Error('Destinazione redirect ambigua');
+        throw new Error('Ambiguous redirect destination');
     return target.pathname + target.search + target.hash;
 }

package/dist/routes.js

@@ -4,14 +4,14 @@ const METHODS = new Set(['get', 'post', 'put', 'patch', 'delete', 'head', 'optio
 export function fileRoute(file, kind) {
     const suffix = kind === 'page' ? '.page.ts' : '.ts';
     if (!file.endsWith(suffix))
-        throw new Error(`Estensione non valida: ${file}`);
+        throw new Error(`Invalid extension: ${file}`);
     let stem = file.slice(0, -suffix.length);
     let method;
     if (kind === 'api') {
         const parts = stem.split('.');
         const candidate = parts.pop();
         if (!METHODS.has(candidate))
-            throw new Error(`L'API ${file} deve specificare il metodo, es. health.get.ts`);
+            throw new Error(`API ${file} must specify a method, e.g. health.get.ts`);
         method = candidate.toUpperCase();
         stem = parts.join('.');
     }
@@ -27,7 +27,7 @@ export function fileRoute(file, kind) {
         const wildcard = /^\[([A-Za-z_][\w]*)\*\]$/.exec(segment);
         if (wildcard) {
             if (index !== normalized.length - 1)
-                throw new Error(`Catch-all non terminale: ${file}`);
+                throw new Error(`Catch-all must be the final segment: ${file}`);
             paths.push(kind === 'page' ? '**' : '*');
             continue;
         }
@@ -37,13 +37,13 @@ export function fileRoute(file, kind) {
         else if (/^[\w-]+$/.test(segment))
             paths.push(segment);
         else
-            throw new Error(`Segmento non supportato in ${file}: ${segment}`);
+            throw new Error(`Unsupported segment in ${file}: ${segment}`);
     }
     if (!segments.length)
-        throw new Error(`Rotta vuota: ${file}`);
+        throw new Error(`Empty route: ${file}`);
     const params = paths.filter((part) => part.startsWith(':'));
     if (new Set(params).size !== params.length)
-        throw new Error(`Parametro duplicato: ${file}`);
+        throw new Error(`Duplicate parameter: ${file}`);
     return { file, path: paths.join('/'), ...(method ? { method } : {}) };
 }
 export function sortAndValidate(routes) {
@@ -51,7 +51,7 @@ export function sortAndValidate(routes) {
     for (const route of routes) {
         const key = `${route.method ?? 'PAGE'} ${route.path.replace(/:[^/]+/g, ':')}`;
         if (seen.has(key))
-            throw new Error(`Collisione tra ${seen.get(key)} e ${route.file}`);
+            throw new Error(`Route collision between ${seen.get(key)} and ${route.file}`);
         seen.set(key, route.file);
     }
     const weight = (segment) => segment.startsWith('*') ? 0 : segment.startsWith(':') ? 1 : 2;
@@ -110,7 +110,7 @@ function leaves(nodes) {
 export function buildPageTree(files) {
     const pages = sortAndValidate(files.filter((file) => file.endsWith('.page.ts')).map((file) => fileRoute(file, 'page')));
     if (pages.some((page) => /(^|\/)layout\.page\.ts$/.test(page.file))) {
-        throw new Error('layout.page.ts è riservato: usa layout.ts per un layout o un altro nome per la pagina');
+        throw new Error('layout.page.ts is reserved: use layout.ts for a layout or another page name');
     }
     const layouts = files.filter((file) => /(^|\/)layout\.ts$/.test(file))
         .sort((a, b) => segments(a).length - segments(b).length || a.localeCompare(b));
@@ -135,10 +135,10 @@ export function buildPageTree(files) {
         // Non includere se stesso nella ricerca del layout genitore.
         const parent = parentFor(file);
         if (/\[\.\.\./.test(directory))
-            throw new Error(`Layout sotto catch-all non supportato: ${file}`);
+            throw new Error(`Layouts below catch-all routes are not supported: ${file}`);
         const fullPath = fileRoute((directory ? directory + '/' : '') + 'index.page.ts', 'page').path;
         if (fullPath.includes('**'))
-            throw new Error(`Layout sotto catch-all non supportato: ${file}`);
+            throw new Error(`Layouts below catch-all routes are not supported: ${file}`);
         const node = makeNode(file, fullPath, 'layout', parent?.node);
         (parent?.node.children ?? roots).push(node);
         parents.push({ directory, node });
@@ -152,7 +152,7 @@ export function buildPageTree(files) {
     }
     for (const file of files.filter((file) => file.endsWith('.route.ts'))) {
         if (!usedMetadata.has(file))
-            throw new Error(`Metadati senza pagina o layout: ${file}`);
+            throw new Error(`Metadata has no matching page or layout: ${file}`);
     }
     const ranks = new Map(pages.map((page, index) => [page.file, index]));
     const rank = (node) => Math.min(...leaves([node]).map((page) => ranks.get(page.file)));
@@ -168,7 +168,7 @@ export function buildPageTree(files) {
     for (let i = 0; i < ordered.length; i++) {
         for (let j = i + 1; j < ordered.length; j++) {
             if (ranks.get(ordered[i].file) > ranks.get(ordered[j].file) && overlaps(ordered[i].fullPath, ordered[j].fullPath)) {
-                throw new Error(`Ordine ambiguo tra ${ordered[i].file} e ${ordered[j].file}: sposta il layout su un antenato comune o separa i percorsi`);
+                throw new Error(`Ambiguous order between ${ordered[i].file} and ${ordered[j].file}: move the layout to a shared ancestor or separate the paths`);
             }
         }
     }

package/dist/server.js

@@ -44,7 +44,7 @@ export async function createServer(options) {
                 async dispatchApi(path, method, body, headers, dispatchOptions = {}) {
                     path = normalizeRedirectLocation(path);
                     if (!path.startsWith('/api/'))
-                        throw new Error('Solo API locali consentite');
+                        throw new Error('Only local API paths are allowed');
                     const forwarded = {};
                     for (const name of ['cookie', 'authorization', 'x-request-label']) {
                         const value = request.headers[name];
@@ -75,7 +75,7 @@ export async function createServer(options) {
             if (context.redirect) {
                 const status = context.redirect.status ?? 302;
                 if (![301, 302, 303, 307, 308].includes(status))
-                    throw new Error('Stato redirect non valido');
+                    throw new Error('Invalid redirect status');
                 const location = normalizeRedirectLocation(context.redirect.location);
                 if (responseCookies.length)
                     reply.header('set-cookie', responseCookies);

package/dist/static-path.js

@@ -1,6 +1,6 @@
 export function staticFile(path) {
     if (!path.startsWith('/') || path.includes('//') || !/^\/[a-zA-Z0-9_/-]*$/.test(path) || path.split('/').includes('..')) {
-        throw new Error(`Percorso di prerendering non supportato: ${path}`);
+        throw new Error(`Unsupported prerender path: ${path}`);
     }
     return `${path.replace(/^\/|\/$/g, '')}${path === '/' ? '' : '/'}index.html`;
 }

package/dist/vite-plugin.js

@@ -1,30 +1,74 @@
 import { generate } from "./routes.js";
+import { resolve } from 'node:path';
+import { checkRoutes, formatCheck } from "./check.js";
 export function isServerModule(id) {
     const path = id.replaceAll('\\', '/').split('?')[0];
     return /\/(src\/server|framework|\.fastang)\//.test(path)
         || /\.server\.[cm]?[jt]s$/.test(path)
-        || /\/(?:@fastang\/core|packages\/core)\/(?:src|dist)\/(?:index|server|http-server|node-handler|listen|angular|api|contract-route|routes|vite|vite-plugin|cli|commands\/.*|adapters\/.*)\.[cm]?[jt]s$/.test(path);
+        || /\/(?:@fastang\/core|packages\/core)\/(?:src|dist)\/(?:index|server|http-server|node-handler|listen|angular|api|contract-route|check|routes|vite|vite-plugin|cli|commands\/.*|adapters\/.*)\.[cm]?[jt]s$/.test(path);
 }
 export function fastang() {
+    let root = process.cwd();
+    const dependencies = new Set();
     return {
+        configResolved(config) { root = config.root; },
         name: 'fastang',
         enforce: 'pre',
         transform(_code, id, options) {
             if (!options?.ssr && isServerModule(id))
-                this.error(`Modulo server importato nel client: ${id}`);
+                this.error(`Server module imported into the client: ${id}`);
+        },
+        async buildStart() {
+            const result = await checkRoutes({ root, onFiles: files => files.forEach(file => dependencies.add(file.replaceAll('\\', '/'))) });
+            if (result.diagnostics.some(d => d.severity === 'error'))
+                this.error(formatCheck(result));
+            if (result.diagnostics.length)
+                this.warn(formatCheck(result));
+            await generate(root);
         },
-        async buildStart() { await generate(); },
         configureServer(server) {
-            // Full reload per cambiamenti della struttura; HMR Angular per i componenti.
             let pending = Promise.resolve();
+            let timer;
+            let closed = false;
             const update = (file) => {
-                if (!/src\/(app\/pages|server\/api)\/.*\.ts$/.test(file.replaceAll('\\', '/')))
+                const path = file.replaceAll('\\', '/');
+                if (!(/src\/(?:server|shared)\/.*\.ts$/.test(path) || /tsconfig[^/]*\.json$/.test(path) || /src\/app\/pages\/.*\.ts$/.test(path) || dependencies.has(path)) || /\/(?:node_modules|dist|\.fastang)\//.test(path) || path.endsWith('/fastang.routes.ts'))
                     return;
-                pending = pending.then(() => generate()).then(() => {
-                    server.ws.send({ type: 'full-reload' });
-                }).catch((error) => server.config.logger.error(String(error)));
+                clearTimeout(timer);
+                timer = setTimeout(() => {
+                    pending = pending.then(async () => {
+                        if (closed)
+                            return;
+                        const result = await checkRoutes({ root, onFiles: files => { files.forEach(file => dependencies.add(file.replaceAll('\\', '/'))); server.watcher.add(files); } });
+                        if (closed)
+                            return;
+                        const message = formatCheck(result);
+                        if (result.diagnostics.some(d => d.severity === 'error')) {
+                            server.config.logger.error(message);
+                            server.ws.send({ type: 'error', err: { message, stack: '', plugin: 'fastang' } });
+                        }
+                        else {
+                            if (result.diagnostics.length)
+                                server.config.logger.warn(message);
+                            await generate(root);
+                            server.ws.send({ type: 'full-reload' });
+                        }
+                    }).catch((error) => {
+                        if (!closed) {
+                            const message = String(error);
+                            server.config.logger.error(message);
+                            server.ws.send({ type: 'error', err: { message, stack: '', plugin: 'fastang' } });
+                        }
+                    });
+                }, 150);
             };
-            server.watcher.on('add', update).on('unlink', update);
+            server.watcher.add([resolve(root, 'src/server'), resolve(root, 'src/shared'), ...dependencies]);
+            server.watcher.on('add', update).on('unlink', update).on('change', (file) => {
+                // Leave Angular page/component HMR to its native plugin.
+                if (!/src\/app\//.test(file.replaceAll('\\', '/')))
+                    update(file);
+            });
+            server.watcher.once('close', () => { closed = true; clearTimeout(timer); });
         },
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fastang/core",
-  "version": "0.1.0-alpha.3",
+  "version": "0.1.0-alpha.5",
   "type": "module",
   "description": "Angular rendering, Fastify APIs and file-based routing.",
   "license": "MIT",