@fastang/core 0.0.0-stage → 0.1.0-alpha.0

package/CHANGELOG.md

@@ -0,0 +1,16 @@
+# Changelog
+
+## 0.1.0-alpha.0
+
+Initial experimental release.
+
+- File-based Angular pages, nested layouts, route metadata and Fastify APIs.
+- Angular SSR, hydration, HTTP transfer cache and per-request rendering state.
+- Local API dispatch through Fastify with validation and serialization.
+- Development CLI, Node production builds and explicit prerendering.
+- Vercel Build Output API adapter with shared or per-route functions.
+- Compiled ESM exports and TypeScript declarations, independently installable.
+
+Targets Angular 22.2.3, Vite 8.3.4 and Fastify 5.12.7 or later in the 5.x line.
+Node 22.22.3+, 24.15+ and 26+ are supported according to package.json.
+The public API is experimental and may change between alpha releases.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dario Chiapperini
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,54 @@
-# Temporary Holding Version
+# @fastang/core
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Experimental FastAng runtime and tooling for Angular + Fastify applications.
+Version 0.1.0-alpha.0 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
+uses one instance of each runtime.
+
+## Installation
+
+Create an app using the matching generator release:
+
+```sh
+npm create fastang@alpha my-app -- --install
+cd my-app
+npm run dev
+```
+
+Registry installation is available once both alpha packages have been published. The local tarball workflow below also works before publication.
+
+## Public entry points
+
+- `@fastang/core`: API definitions, configuration, HTTP server factories, Node handler, listen and rendering context types.
+- `@fastang/core/angular`: `createRenderer(RootComponent, createAppConfig)` with per-request providers, HTTP transfer cache and router redirects.
+- `@fastang/core/vite`: `defineFastangConfig()` for Angular compilation, generated routes and server/client boundaries.
+- `@fastang/core/config`, `/api`, `/server`, `/http-server`, `/node-handler`, `/listen`, `/render-context`: focused imports.
+- `/routes`, `/adapters/vercel`, `/adapters/vercel-plan`, `/vite-plugin`: lower-level tooling APIs; still experimental.
+
+`createServer()` and `createApiServer()` accept a `registerApi(app)` callback.
+The framework never imports application files; the generated `.fastang/api.ts`
+module belongs to the consuming app.
+
+## Commands
+
+`fastang generate` generates routes in the current application. `fastang dev`
+starts Vite and Fastify on port 3278 and restarts the backend after changes.
+`fastang build` builds the client, Node server and explicit prerender URLs.
+`fastang build --vercel` also creates the Vercel Build Output API directory.
+Run Angular and TypeScript checks before a build, as shown in the starter.
+
+The current conventions expect `fastang.config.ts`, `vite.config.ts`,
+`src/main.server.ts`, `src/server/{index,start,api-entry,vercel-entry,plugins}.ts`
+and `src/app/omitted.server.ts`. The starter supplies these application bindings.
+
+To build and create a tarball from the repository root:
+
+```sh
+npm ci
+npm pack --workspace @fastang/core --pack-destination /tmp
+```
+
+Install the tarball into a copy of `examples/starter`. No global CLI, repository
+source files or website assets are required by the installed package.

package/bin/fastang.mjs

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../dist/cli.js';

package/dist/adapters/vercel-plan.d.ts

@@ -0,0 +1,22 @@
+import type { VercelOptions } from '../config.ts';
+import { type FileRoute } from '../routes.ts';
+export interface FunctionPlan {
+    name: string;
+    kind: 'api' | 'ssr';
+    entry: string;
+    paths: string[];
+    sources: FileRoute[];
+    bundle?: string;
+    routesModule?: string;
+    renderedComponents?: string[];
+}
+export interface VercelPlan {
+    mode: 'shared' | 'routes';
+    functions: FunctionPlan[];
+}
+export declare const escapeRegex: (value: string) => string;
+/** Match an entire route; parameter segments never consume a slash. */
+export declare function routePattern(path: string): string;
+export declare function planVercelFunctions(pages: FileRoute[], apis: FileRoute[], prerendered: string[], options?: VercelOptions): VercelPlan;
+/** Generates API entries and component-pruned route graphs for page functions. */
+export declare function prepareVercelPlan(prerendered: string[], options?: VercelOptions, root?: string): Promise<VercelPlan>;

package/dist/adapters/vercel-plan.js

@@ -0,0 +1,90 @@
+import { createHash } from 'node:crypto';
+import { mkdir, rm, writeFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { discover, discoverPageTree, pageRoutesSource, renderedPageFiles } from "../routes.js";
+export const escapeRegex = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+/** Match an entire route; parameter segments never consume a slash. */
+export function routePattern(path) {
+    const segments = path.split('/').filter(Boolean);
+    return '^/' + segments.map((part) => part.startsWith(':') ? '[^/]+' : part === '*' || part === '**' ? '.*' : escapeRegex(part)).join('/') + (segments.length ? '/?' : '') + '$';
+}
+const signature = (path) => path.replace(/:[^/]+/g, ':param');
+function identifier(path) {
+    const normalized = signature(path);
+    const slug = normalized.replace(/[^a-zA-Z0-9]+/g, '-').replace(/^-|-$/g, '').slice(0, 45) || 'index';
+    return slug + '-' + createHash('sha256').update(normalized).digest('hex').slice(0, 12);
+}
+export function planVercelFunctions(pages, apis, prerendered, options = {}) {
+    const mode = options.functions ?? 'shared';
+    if (mode !== 'shared' && mode !== 'routes')
+        throw new Error('vercel.functions must be shared or routes');
+    const prefixes = [...new Set(options.pagePrefixes ?? [''])];
+    if (!prefixes.length || prefixes.some((prefix) => prefix !== '' && !/^\/(?:[\w-]+)(?:\/[\w-]+)*$/.test(prefix))) {
+        throw new Error('vercel.pagePrefixes must contain empty or absolute static prefixes without a trailing slash');
+    }
+    if (prefixes.some((prefix) => /^\/(?:api|assets|__fastang)(?:\/|$)/.test(prefix)))
+        throw new Error('Reserved Vercel page prefix');
+    const functions = [
+        { name: mode === 'routes' ? '__fastang/ssr' : 'ssr', kind: 'ssr', entry: 'vercel', paths: [], sources: [] },
+        { name: mode === 'routes' ? '__fastang/api' : 'api', kind: 'api', entry: 'api', paths: [], sources: [] },
+    ];
+    if (mode === 'shared')
+        return { mode, functions };
+    // Discovery order is already specific-first. Catch-alls stay with the full router.
+    const seen = new Map();
+    const staticPaths = new Set(prerendered.map((path) => path.replace(/\/$/, '') || '/'));
+    for (const page of pages.filter((page) => !page.path.includes('**'))) {
+        const paths = prefixes.map((prefix) => prefix + (page.path ? '/' + page.path : '') || '/')
+            .filter((path) => !staticPaths.has(path));
+        for (const path of paths) {
+            if (/^\/(?:api|assets|__fastang)(?:\/|$)/.test(path))
+                throw new Error(`Reserved page path: ${path}`);
+            const key = signature(path);
+            if (seen.has(key))
+                throw new Error(`Overlapping Vercel page aliases: ${seen.get(key)} and ${page.file}`);
+            seen.set(key, page.file);
+        }
+        if (paths.length)
+            functions.push({ name: '__fastang/pages/' + identifier(page.path), kind: 'ssr', entry: 'vercel', paths, sources: [page] });
+    }
+    const groups = new Map();
+    for (const api of apis) {
+        const key = signature(api.path);
+        const group = groups.get(key) ?? [];
+        group.push(api);
+        groups.set(key, group);
+    }
+    for (const [path, sources] of groups) {
+        const id = identifier(path);
+        functions.push({ name: '__fastang/endpoints/' + id, kind: 'api', entry: 'endpoint-' + id, paths: ['/api' + (sources[0].path ? '/' + sources[0].path : '')], sources });
+    }
+    return { mode, functions };
+}
+/** Generates API entries and component-pruned route graphs for page functions. */
+export async function prepareVercelPlan(prerendered, options, root = process.cwd()) {
+    const [pages, apis] = await Promise.all([
+        discover(resolve(root, 'src/app/pages'), 'page'),
+        discover(resolve(root, 'src/server/api'), 'api'),
+    ]);
+    const plan = planVercelFunctions(pages, apis, prerendered, options);
+    const directory = resolve(root, '.fastang/vercel');
+    await rm(directory, { recursive: true, force: true });
+    await mkdir(directory, { recursive: true });
+    const tree = await discoverPageTree(resolve(root, 'src/app/pages'));
+    for (const fn of plan.functions.filter((fn) => options?.prunePages !== false && fn.sources.length && fn.kind === 'ssr')) {
+        const id = fn.name.split('/').at(-1);
+        fn.bundle = `dist/pages/${id}/server/index.js`;
+        fn.routesModule = `.fastang/vercel/${id}.routes.ts`;
+        fn.renderedComponents = renderedPageFiles(tree, fn.sources[0].file);
+        await writeFile(resolve(root, fn.routesModule), pageRoutesSource(tree, {
+            pagesImport: '../../src/app/pages/', selectedFile: fn.sources[0].file,
+            omittedImport: '../../src/app/omitted.server',
+        }));
+    }
+    for (const fn of plan.functions.filter((fn) => fn.sources.length && fn.kind === 'api')) {
+        const imports = fn.sources.map((route, index) => `import route${index} from ${JSON.stringify('../../src/server/api/' + route.file.slice(0, -3))};`).join('\n');
+        const registrations = fn.sources.map((route, index) => `    route${index}(app, ${JSON.stringify(route.method)}, ${JSON.stringify('/api' + (route.path ? '/' + route.path : ''))});`).join('\n');
+        await writeFile(resolve(directory, fn.entry + '.ts'), `// Generated by FastAng.\nimport { createHttpServer } from '@fastang/core/http-server';\nimport { createNodeHandler } from '@fastang/core/node-handler';\nimport { configureServer } from '../../src/server/plugins.ts';\n${imports}\nexport default createNodeHandler(() => createHttpServer({\n  configure: async (app) => {\n    await configureServer(app);\n${registrations}\n  },\n}));\n`);
+    }
+    return plan;
+}

package/dist/adapters/vercel.d.ts

@@ -0,0 +1,3 @@
+import { type VercelPlan } from './vercel-plan.ts';
+/** Converts an existing Node build into Vercel Build Output API v3. */
+export declare function buildVercelOutput(plan: VercelPlan, root?: string): Promise<void>;

package/dist/adapters/vercel.js

@@ -0,0 +1,80 @@
+import { copyFile, mkdir, readFile, rm, stat, writeFile } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import { createRequire } from 'node:module';
+import { nodeFileTrace } from '@vercel/nft';
+import { staticFile } from "../server.js";
+import { sortAndValidate } from "../routes.js";
+import { escapeRegex, routePattern } from "./vercel-plan.js";
+/** Converts an existing Node build into Vercel Build Output API v3. */
+export async function buildVercelOutput(plan, root = process.cwd()) {
+    const output = resolve(root, '.vercel/output');
+    const prerendered = JSON.parse(await readFile(resolve(root, 'dist/prerender.json'), 'utf8'));
+    // Validate before touching the previous output.
+    for (const path of prerendered)
+        staticFile(path);
+    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 { cp } = await import('node:fs/promises');
+    await cp(resolve(root, 'dist/client/assets'), resolve(output, 'static/assets'), { recursive: true });
+    for (const path of prerendered) {
+        const file = staticFile(path);
+        await copy(`dist/client/${file}`, resolve(output, 'static', file));
+    }
+    const report = [];
+    const traces = new Map();
+    for (const { name, entry, kind, bundle } of plan.functions) {
+        const directory = resolve(output, `functions/${name}.func`);
+        const entryFile = bundle ?? `dist/server/${entry}.js`;
+        // The bundled CommonJS runtime uses a require shim that tracing cannot
+        // always recognize. Trace Fastify's original graph for external helpers.
+        const fastifyEntry = createRequire(resolve(root, 'package.json')).resolve('fastify');
+        const trace = traces.get(entryFile) ?? await nodeFileTrace([entryFile, fastifyEntry], {
+            base: root, processCwd: root,
+            // Only the private SSR template is needed; public assets stay on the CDN.
+            ignore: ['dist/**/client/**', 'dist/client/**', 'dist/**/prerender.json', 'dist/prerender.json'],
+        });
+        traces.set(entryFile, trace);
+        for (const warning of trace.warnings)
+            console.warn(`[vercel:${name}] ${warning.message}`);
+        for (const file of trace.fileList) {
+            if (file.startsWith('../') || file.startsWith('/'))
+                throw new Error(`Dependency outside project: ${file}`);
+            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 });
+        await writeFile(resolve(directory, '.vc-config.json'), JSON.stringify({
+            runtime: 'nodejs24.x', launcherType: 'Nodejs', handler: entryFile,
+            shouldAddHelpers: false, supportsResponseStreaming: true,
+        }, null, 2) + '\n');
+        const sizes = await Promise.all([...trace.fileList].map(async (file) => ({ file, size: (await stat(resolve(root, file))).size })));
+        report.push({
+            name, tracedFiles: trace.fileList.size,
+            tracedBytes: sizes.reduce((sum, item) => sum + item.size, 0),
+            serverJavaScriptBytes: sizes.filter(({ file }) => file.startsWith('dist/') && file.endsWith('.js')).reduce((sum, item) => sum + item.size, 0),
+            pageJavaScriptBytes: sizes.filter(({ file }) => file.startsWith('dist/') && /(?:\.page-|\/layout-).*\.js$/.test(file)).reduce((sum, item) => sum + item.size, 0),
+        });
+        console.log(`Vercel ${name}: ${trace.fileList.size} traced files`);
+    }
+    await writeFile(resolve(output, 'config.json'), JSON.stringify({
+        version: 3,
+        routes: [
+            { src: '/(.*)', headers: { 'X-Content-Type-Options': 'nosniff' }, continue: true },
+            { src: '/assets/(.*)', headers: { 'Cache-Control': 'public, max-age=31536000, immutable' }, continue: true },
+            ...prerendered.map((path) => ({
+                src: `^${escapeRegex(path)}/?$`, methods: ['GET', 'HEAD'],
+                dest: '/' + staticFile(path), headers: { 'X-Fastang-Render': 'prerender', 'Cache-Control': 'public, max-age=0, must-revalidate' },
+            })),
+            { handle: 'filesystem' },
+            ...sortAndValidate(plan.functions.flatMap((fn) => fn.paths.map((path) => ({ file: fn.name, path: path.replace(/^\//, '') })))).map((route) => ({ src: routePattern('/' + route.path), dest: '/' + route.file })),
+            { src: '^/api(?:/.*)?$', dest: '/' + plan.functions.find((fn) => fn.kind === 'api' && !fn.paths.length).name },
+            { src: '/(.*)', dest: '/' + plan.functions.find((fn) => fn.kind === 'ssr' && !fn.paths.length).name },
+        ],
+    }, null, 2) + '\n');
+    await writeFile(resolve(root, 'dist/vercel-bundle-report.json'), JSON.stringify({ version: 1, functions: report }, null, 2) + '\n');
+    await writeFile(resolve(root, 'dist/vercel-manifest.json'), JSON.stringify(plan, null, 2) + '\n');
+}

package/dist/angular.d.ts

@@ -0,0 +1,3 @@
+import type { ApplicationConfig, Type } from '@angular/core';
+import type { RenderContext } from './render-context.ts';
+export declare function createRenderer(App: Type<unknown>, createAppConfig: () => ApplicationConfig): (url: string, document: string, context: RenderContext) => Promise<string>;

package/dist/angular.js

@@ -0,0 +1,55 @@
+import { REQUEST_CONTEXT, DestroyRef, inject, mergeApplicationConfig, provideAppInitializer } from '@angular/core';
+import { NavigationEnd, Router } from '@angular/router';
+import { bootstrapApplication } from '@angular/platform-browser';
+import { provideServerRendering, renderApplication } from '@angular/platform-server';
+import { HttpBackend, FetchBackend, HttpResponse, HttpHeaders, HttpErrorResponse } from '@angular/common/http';
+import { from, map } from 'rxjs';
+// Il backend opera DOPO gli interceptor Angular, inclusa la transfer cache nativa.
+// Un interceptor che risponde prima di next() scavalcherebbe quella cache.
+function localApiBackend() {
+    const upstream = inject(FetchBackend);
+    const context = inject(REQUEST_CONTEXT);
+    return {
+        handle(request) {
+            const target = new URL(request.urlWithParams, 'http://fastang.local');
+            if (target.origin !== 'http://fastang.local' || !target.pathname.startsWith('/api/'))
+                return upstream.handle(request);
+            const headers = Object.fromEntries(request.headers.keys().map((key) => [key, request.headers.get(key)]));
+            const contentType = request.detectContentTypeHeader();
+            if (contentType && !request.headers.has('content-type'))
+                headers['content-type'] = contentType;
+            return from(context.dispatchApi(target.pathname + target.search, request.method, request.body, headers)).pipe(map((response) => {
+                const responseHeaders = new HttpHeaders(response.headers);
+                if (response.status >= 400)
+                    throw new HttpErrorResponse({ status: response.status, error: response.body, headers: responseHeaders, url: request.url });
+                return new HttpResponse({ status: response.status, body: response.body, headers: responseHeaders, url: request.url });
+            }));
+        },
+    };
+}
+export function createRenderer(App, createAppConfig) {
+    return async function render(url, document, context) {
+        // I provider con stato mutabile vengono ricreati per ogni applicazione SSR.
+        const config = mergeApplicationConfig(createAppConfig(), {
+            providers: [
+                provideServerRendering(),
+                { provide: HttpBackend, useFactory: localApiBackend },
+                provideAppInitializer(() => {
+                    const router = inject(Router);
+                    const target = new URL(url);
+                    const incoming = router.serializeUrl(router.parseUrl(target.pathname + target.search + target.hash));
+                    const subscription = router.events.subscribe((event) => {
+                        if (event instanceof NavigationEnd) {
+                            // Confronta URL canoniche Angular, non la codifica originale della query.
+                            context.redirect = event.urlAfterRedirects === incoming
+                                ? undefined
+                                : { location: event.urlAfterRedirects, status: 302 };
+                        }
+                    });
+                    inject(DestroyRef).onDestroy(() => subscription.unsubscribe());
+                }),
+            ],
+        });
+        return renderApplication((bootstrapContext) => bootstrapApplication(App, config, bootstrapContext), { url, document, allowedHosts: ['fastang.local'], platformProviders: [{ provide: REQUEST_CONTEXT, useValue: context }] });
+    };
+}

package/dist/api.d.ts

@@ -0,0 +1,7 @@
+import type { FastifyInstance, FastifySchema, HTTPMethods, RawReplyDefaultExpression, RawRequestDefaultExpression, RawServerDefault, RouteGenericInterface, RouteHandlerMethod } from 'fastify';
+type Handler<T extends RouteGenericInterface> = RouteHandlerMethod<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, T>;
+export declare function defineApiRoute<T extends RouteGenericInterface>(options: {
+    schema: FastifySchema;
+    handler: Handler<T>;
+}): (app: FastifyInstance, method: HTTPMethods, url: string) => void;
+export {};

package/dist/api.js

@@ -0,0 +1,4 @@
+// I tipi rimangono nel closure: nessun cast quando si registra la rotta generata.
+export function defineApiRoute(options) {
+    return (app, method, url) => { app.route({ ...options, method, url }); };
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+const command = process.argv[2];
+try {
+    if (command === 'generate')
+        await (await import("./routes.js")).generate();
+    else if (command === 'dev')
+        await import("./commands/dev.js");
+    else if (command === 'build')
+        await import("./commands/build.js");
+    else if (!command || command === '--help' || command === '-h')
+        console.log('Usage: fastang <dev|generate|build> [--vercel]');
+    else
+        throw new Error(`Unknown command: ${command}`);
+}
+catch (error) {
+    console.error(error instanceof Error ? error.message : error);
+    process.exitCode = 1;
+}
+export {};

package/dist/commands/build.d.ts

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

package/dist/commands/build.js

@@ -0,0 +1,71 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { mkdir, rm, writeFile } from 'node:fs/promises';
+import { resolve, dirname } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { build } from 'vite';
+import { loadConfigFromFile } from 'vite';
+import { prepareVercelPlan } from "../adapters/vercel-plan.js";
+import { buildVercelOutput } from "../adapters/vercel.js";
+import { staticFile } from "../server.js";
+const loaded = await loadConfigFromFile({ command: 'build', mode: 'production' }, 'fastang.config.ts');
+if (!loaded)
+    throw new Error('Missing fastang.config.ts');
+const config = loaded.config;
+const vercel = process.argv.includes('--vercel');
+await rm('dist', { recursive: true, force: true });
+const paths = [...new Set(config.prerender)];
+for (const path of paths) {
+    staticFile(path);
+    if (path === '/' || path === '/api' || path.startsWith('/api/') || path.startsWith('/assets/')) {
+        throw new Error(`Percorso riservato al runtime: ${path}`);
+    }
+}
+const vercelPlan = vercel ? await prepareVercelPlan(paths, config.vercel) : undefined;
+const endpointEntries = Object.fromEntries((vercelPlan?.functions ?? []).filter((fn) => fn.entry.startsWith('endpoint-')).map((fn) => [fn.entry, `.fastang/vercel/${fn.entry}.ts`]));
+await build({ build: { outDir: 'dist/client' } });
+await build({ build: {
+        outDir: 'dist/server', minify: true, ssr: vercel ? true : 'src/server/start.ts',
+        rollupOptions: {
+            ...(vercel ? { input: { index: 'src/server/start.ts', vercel: 'src/server/vercel-entry.ts', api: 'src/server/api-entry.ts', ...endpointEntries } } : {}),
+            output: { entryFileNames: vercel ? '[name].js' : 'index.js', ...(vercel ? { chunkFileNames: '[name]-[hash].js' } : {}) },
+        },
+    } });
+// Each page build has its own module graph. A multi-entry build would pull
+// unrelated lazy components back in through the full-router fallback entry.
+for (const fn of vercelPlan?.functions ?? []) {
+    if (!fn.bundle || !fn.routesModule)
+        continue;
+    await build({
+        resolve: { alias: [{ find: /^\.\/fastang\.routes$/, replacement: resolve(fn.routesModule) }] },
+        build: {
+            outDir: dirname(fn.bundle), minify: true, ssr: 'src/server/vercel-entry.ts',
+            rollupOptions: { output: { entryFileNames: 'index.js', chunkFileNames: '[name]-[hash].js' } },
+        },
+    });
+}
+const { createProductionServer } = await import(__rewriteRelativeImportExtension(pathToFileURL(resolve('dist/server/index.js')).href));
+const app = await createProductionServer({ prerender: false });
+try {
+    for (const path of paths) {
+        const response = await app.inject({ url: path });
+        if (response.statusCode !== 200)
+            throw new Error(`Prerender ${path}: HTTP ${response.statusCode}`);
+        const target = resolve('dist/client', staticFile(path));
+        await mkdir(dirname(target), { recursive: true });
+        await writeFile(target, response.body);
+        console.log(`Prerendered ${path}`);
+    }
+    await writeFile('dist/prerender.json', JSON.stringify(paths, null, 2) + '\n');
+}
+finally {
+    await app.close();
+}
+if (vercelPlan)
+    await buildVercelOutput(vercelPlan);

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

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

package/dist/commands/dev-server.js

@@ -0,0 +1,41 @@
+import { readFile } from 'node:fs/promises';
+import { createServer as createViteServer } from 'vite';
+import middie from '@fastify/middie';
+import { createServer } from "../server.js";
+import { listen } from "../listen.js";
+import { tsImport } from 'tsx/esm/api';
+import { resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+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,
+        async configure(server) {
+            vite = await createViteServer({ 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.
+            server.use(vite.middlewares);
+            await configureServer(server);
+        },
+        async template(url) { return vite.transformIndexHtml(url, await readFile('index.html', 'utf8')); },
+        async render(url, document, context) {
+            try {
+                const module = await vite.ssrLoadModule('/src/main.server.ts');
+                return await module['render'](url, document, context);
+            }
+            catch (error) {
+                if (error instanceof Error)
+                    vite.ssrFixStacktrace(error);
+                throw error;
+            }
+        },
+    });
+    await listen(app);
+}
+catch (error) {
+    await vite?.close();
+    throw error;
+}

package/dist/commands/dev.d.ts

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

package/dist/commands/dev.js

@@ -0,0 +1,46 @@
+import { existsSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { watch } from 'node:fs';
+import { spawn } from 'node:child_process';
+import { once } from 'node:events';
+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;
+    // 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');
+    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; });
+}
+function changed() {
+    clearTimeout(timer);
+    timer = setTimeout(() => {
+        queue = queue.then(restart).catch((error) => console.error(error));
+    }, 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));
+async function shutdown() {
+    stopping = true;
+    clearTimeout(timer);
+    watchers.forEach((watcher) => watcher.close());
+    await queue;
+    await stopChild();
+}
+process.once('SIGINT', shutdown);
+process.once('SIGTERM', shutdown);
+await restart();

package/dist/config.d.ts

@@ -0,0 +1,13 @@
+export interface VercelOptions {
+    /** Shared functions are the default; routes creates separate deployment functions. */
+    functions?: 'shared' | 'routes';
+    /** Public prefixes added by the application router, e.g. ['', '/en']. */
+    pagePrefixes?: string[];
+    /** Keep only the selected page/layout components in route functions. Default: true. */
+    prunePages?: boolean;
+}
+export interface FastangConfig {
+    prerender: string[];
+    vercel?: VercelOptions;
+}
+export declare function defineConfig(config: FastangConfig): FastangConfig;

package/dist/config.js

@@ -0,0 +1,3 @@
+export function defineConfig(config) {
+    return config;
+}

package/dist/http-server.d.ts

@@ -0,0 +1,6 @@
+import { type FastifyInstance, type FastifyServerOptions } from 'fastify';
+export interface HttpServerOptions {
+    logger?: FastifyServerOptions['logger'];
+    configure?: (app: FastifyInstance) => Promise<void> | void;
+}
+export declare function createHttpServer(options?: HttpServerOptions): Promise<FastifyInstance>;

package/dist/http-server.js

@@ -0,0 +1,19 @@
+import Fastify, {} from 'fastify';
+export async function createHttpServer(options = {}) {
+    const app = Fastify({ logger: options.logger ?? false, bodyLimit: 1024 * 1024 });
+    try {
+        await options.configure?.(app);
+        app.setNotFoundHandler((_request, reply) => reply.code(404).send({ error: 'Not found' }));
+        app.setErrorHandler((error, request, reply) => {
+            request.log.error(error);
+            const statusCode = error && typeof error === 'object' && 'statusCode' in error ? error.statusCode : 500;
+            const status = typeof statusCode === 'number' && statusCode >= 400 && statusCode < 500 ? statusCode : 500;
+            reply.code(status).send({ error: status === 500 ? 'Internal server error' : error instanceof Error ? error.message : 'Bad request' });
+        });
+        return app;
+    }
+    catch (error) {
+        await app.close();
+        throw error;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './api.ts';
+export * from './config.ts';
+export * from './server.ts';
+export * from './node-handler.ts';
+export * from './listen.ts';
+export type * from './render-context.ts';

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from "./api.js";
+export * from "./config.js";
+export * from "./server.js";
+export * from "./node-handler.js";
+export * from "./listen.js";

package/dist/listen.d.ts

@@ -0,0 +1,4 @@
+import type { FastifyInstance } from 'fastify';
+/** FAST on a telephone keypad. PORT can override this local convention. */
+export declare const DEFAULT_PORT = 3278;
+export declare function listen(app: FastifyInstance): Promise<void>;