create-fastang 0.0.0-stage → 0.1.0-alpha.1

package/CHANGELOG.md

@@ -0,0 +1,18 @@
+# Changelog
+
+## 0.1.0-alpha.1
+
+- Pin the generated starter to @fastang/core 0.1.0-alpha.1, with runtime configuration validation and the explicit SSR HTTP contract.
+
+## 0.1.0-alpha.0
+
+Initial experimental release.
+
+- Generate an independent Angular + Fastify application.
+- Include a home page, prerendered page, SSR API example and HTTP 404 page.
+- Use the same starter source maintained in the repository.
+- Customize the npm package name and optionally install dependencies.
+- Support local core tarballs before registry publication.
+- Reject existing destinations and exclude local/generated files from templates.
+
+The generator pins the matching @fastang/core alpha release.

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,63 @@
-# Temporary Holding Version
+# create-fastang
 
-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.
+Generate a minimal Angular + Fastify application with FastAng.
+
+This is an experimental alpha package. Use the explicit `alpha` tag for the prerelease:
+
+```sh
+npm create fastang@alpha my-app -- --install
+cd my-app
+npm run dev
+```
+
+Registry installation is available once the generator and matching core release have been published. For local release testing, use the tarball workflow below.
+
+## Use from this repository
+
+At the repository root:
+
+```sh
+npm ci
+npm pack --workspace @fastang/core --pack-destination /tmp
+npm run create -- /tmp/my-fastang-app --core-package /tmp/fastang-core-0.1.0-alpha.1.tgz
+cd /tmp/my-fastang-app
+npm install
+npm run dev
+```
+
+Open http://localhost:3278. Use PORT and HOST to override the defaults.
+The core tarball must remain available for future clean dependency installations.
+
+## Test the packaged generator
+
+```sh
+npm pack --workspace create-fastang --pack-destination /tmp
+npm exec --package=/tmp/create-fastang-0.1.0-alpha.1.tgz -- create-fastang /tmp/another-app --core-package /tmp/fastang-core-0.1.0-alpha.1.tgz
+```
+
+No checkout files are required by either installed package. The generated app
+includes its own configuration, Node and Vercel entries, pages and API endpoints.
+
+## Options
+
+- `<directory>`: new project directory. Existing files, folders and symlinks are rejected, including an existing empty directory. Without an argument, an interactive terminal asks for the directory; automation must provide one explicitly.
+- `--name <name>`: npm package name, including scoped names. Otherwise a lowercase name is derived from the directory.
+- `--core-package <file.tgz>`: local core package for use before registry publication.
+- `--install`: run npm install after generating the project. On failure, the generated files remain available for retrying installation.
+- `--no-install`: generate files only; this is the default.
+- `--help`, `--version`: show usage or generator version.
+
+There are no git operations, global installations or deployments. Use the
+project's `npm run build:vercel` command when preparing a Vercel deployment.
+
+## Maintain the template
+
+`examples/starter` is the single source of application files. `npm run build
+--workspace create-fastang` compiles the generator and prepares its distributable
+template. `prepack` runs this build automatically. Build output, dependencies,
+local environment files and generated routes are excluded. `.gitignore` is
+shipped as `_gitignore` and restored when creating an app.
+
+`npm run test:starter` installs both tarballs outside the workspace, invokes the
+installed generator and verifies the generated application, including development
+restarts and an actual packaged Vercel function.

package/bin/create-fastang.mjs

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { main } from '../dist/cli.js';
+try { await main(); }
+catch (error) {
+  console.error(`create-fastang: ${error instanceof Error ? error.message : error}`);
+  process.exitCode = 1;
+}

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export declare function main(args?: string[]): Promise<void>;

package/dist/cli.js

@@ -0,0 +1,90 @@
+import { createInterface } from 'node:readline/promises';
+import { spawn } from 'node:child_process';
+import { readFile } from 'node:fs/promises';
+import { relative } from 'node:path';
+import { createProject } from "./create.js";
+const help = `Usage: create-fastang <directory> [options]
+
+Create a minimal Angular + Fastify project in a new directory.
+
+  --name <name>          Set the npm package name
+  --install              Install dependencies with npm
+  --no-install           Generate files only (default)
+  --core-package <file>   Use a local @fastang/core .tgz before npm publication
+  -h, --help             Show this help
+  -v, --version          Show generator version
+
+Example: create-fastang my-app --core-package /tmp/fastang-core-0.1.0-alpha.1.tgz
+`;
+const quote = (value) => /^[a-zA-Z0-9_./-]+$/.test(value) ? value : `'${value.replaceAll("'", "'\"'\"'")}'`;
+export async function main(args = process.argv.slice(2)) {
+    if (args.includes('--help') || args.includes('-h')) {
+        console.log(help);
+        return;
+    }
+    if (args.includes('--version') || args.includes('-v')) {
+        console.log(JSON.parse(await readFile(new URL('../package.json', import.meta.url), 'utf8')).version);
+        return;
+    }
+    let directory;
+    let name;
+    let corePackage;
+    let install = false;
+    let installationOption;
+    let positional = false;
+    for (let index = 0; index < args.length; index++) {
+        const arg = args[index];
+        if (!positional && arg === '--') {
+            positional = true;
+            continue;
+        }
+        if (!positional && ['--name', '--core-package'].includes(arg)) {
+            const value = args[++index];
+            if (!value || value.startsWith('--'))
+                throw new Error(`Missing value for ${arg}.`);
+            if (arg === '--name')
+                name = value;
+            else
+                corePackage = value;
+        }
+        else if (!positional && ['--install', '--no-install'].includes(arg)) {
+            if (installationOption && installationOption !== arg)
+                throw new Error('Choose either --install or --no-install.');
+            installationOption = arg;
+            install = arg === '--install';
+        }
+        else if (!positional && arg.startsWith('-'))
+            throw new Error(`Unknown option: ${arg}. Run create-fastang --help.`);
+        else if (directory !== undefined)
+            throw new Error('Provide exactly one project directory.');
+        else
+            directory = arg;
+    }
+    if (directory === undefined) {
+        if (!process.stdin.isTTY || !process.stdout.isTTY)
+            throw new Error('Provide a project directory. Run create-fastang --help.');
+        const prompt = createInterface({ input: process.stdin, output: process.stdout });
+        try {
+            directory = (await prompt.question('Project directory (fastang-app): ')).trim() || 'fastang-app';
+        }
+        finally {
+            prompt.close();
+        }
+    }
+    const project = await createProject({ directory, name, corePackage });
+    console.log(`\nCreated ${project.name} in ${project.directory}`);
+    if (install) {
+        console.log('\nInstalling dependencies with npm…');
+        await new Promise((resolve, reject) => {
+            const child = spawn(process.platform === 'win32' ? 'npm.cmd' : 'npm', ['install'], { cwd: project.directory, stdio: 'inherit', shell: process.platform === 'win32' });
+            child.once('error', reject);
+            child.once('exit', code => code === 0 ? resolve() : reject(new Error('npm install failed. Project files are preserved; run npm install in the project to retry.')));
+        });
+    }
+    const path = relative(process.cwd(), project.directory) || '.';
+    console.log('\nNext steps:');
+    console.log(process.platform === 'win32' ? `  Open ${project.directory}` : `  cd ${quote(path.startsWith('-') ? './' + path : path)}`);
+    if (!install)
+        console.log('  npm install');
+    console.log('  npm run dev\n\nhttp://localhost:3278');
+}

package/dist/create.d.ts

@@ -0,0 +1,14 @@
+export interface CreateOptions {
+    directory: string;
+    cwd?: string;
+    name?: string;
+    corePackage?: string;
+}
+export declare function packageName(directory: string): string;
+export declare function validatePackageName(name: string): void;
+/** Generate atomically into a new directory; existing paths are never replaced. */
+export declare function createProject(options: CreateOptions): Promise<{
+    directory: string;
+    name: string;
+    localCore: boolean;
+}>;

package/dist/create.js

@@ -0,0 +1,56 @@
+import { cp, lstat, mkdir, mkdtemp, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { basename, dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+export function packageName(directory) {
+    return basename(resolve(directory)).toLowerCase().replace(/[^a-z0-9._-]+/g, '-').replace(/^[._-]+|[._-]+$/g, '') || 'fastang-app';
+}
+export function validatePackageName(name) {
+    if (name.length > 214 || !/^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/.test(name) || ['node_modules', 'favicon.ico'].includes(name)) {
+        throw new Error('Invalid npm package name. Use lowercase letters, numbers, dots, hyphens or underscores.');
+    }
+}
+/** Generate atomically into a new directory; existing paths are never replaced. */
+export async function createProject(options) {
+    if (!options.directory.trim())
+        throw new Error('Provide a new project directory.');
+    const cwd = options.cwd ?? process.cwd();
+    const directory = resolve(cwd, options.directory);
+    const name = options.name ?? packageName(directory);
+    validatePackageName(name);
+    if (await lstat(directory).then(() => true, (error) => {
+        if (error.code === 'ENOENT')
+            return false;
+        throw error;
+    }))
+        throw new Error(`Destination already exists: ${directory}. Choose a new directory.`);
+    let corePackage;
+    if (options.corePackage) {
+        corePackage = resolve(cwd, options.corePackage);
+        if (!(await lstat(corePackage)).isFile() || !corePackage.endsWith('.tgz'))
+            throw new Error('--core-package must point to a local npm .tgz package.');
+    }
+    const template = fileURLToPath(new URL('../template/', import.meta.url));
+    const manifest = JSON.parse(await readFile(resolve(template, 'package.json'), 'utf8'));
+    manifest.name = name;
+    if (corePackage)
+        manifest.dependencies['@fastang/core'] = `file:${corePackage}`;
+    await mkdir(dirname(directory), { recursive: true });
+    const staging = await mkdtemp(resolve(dirname(directory), '.fastang-create-'));
+    try {
+        await cp(template, resolve(staging, 'project'), { recursive: true, force: false, errorOnExist: true });
+        await rename(resolve(staging, 'project/_gitignore'), resolve(staging, 'project/.gitignore'));
+        await writeFile(resolve(staging, 'project/package.json'), JSON.stringify(manifest, null, 2) + '\n');
+        // Recheck before rename: do not replace a directory created while copying.
+        if (await lstat(directory).then(() => true, (error) => {
+            if (error.code === 'ENOENT')
+                return false;
+            throw error;
+        }))
+            throw new Error(`Destination already exists: ${directory}. Choose a new directory.`);
+        await rename(resolve(staging, 'project'), directory);
+    }
+    finally {
+        await rm(staging, { recursive: true, force: true });
+    }
+    return { directory, name, localCore: Boolean(corePackage) };
+}

package/package.json

@@ -1,6 +1,46 @@
 {
   "name": "create-fastang",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0-alpha.1",
+  "type": "module",
+  "description": "Create an Angular + Fastify project with FastAng.",
+  "license": "MIT",
+  "engines": {
+    "node": "^22.22.3 || ^24.15.0 || >=26.0.0"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "template",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "bin": {
+    "create-fastang": "./bin/create-fastang.mjs"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/create.d.ts",
+      "import": "./dist/create.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && node scripts/build-template.mjs",
+    "prepack": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/daclab-dev/fastang.git",
+    "directory": "packages/create-fastang"
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "alpha",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "homepage": "https://fastang.dev",
+  "bugs": {
+    "url": "https://github.com/daclab-dev/fastang/issues"
+  },
+  "author": "Dario Chiapperini"
+}

package/template/README.md

@@ -0,0 +1,31 @@
+# FastAng app
+
+Angular pages, Fastify APIs and server rendering.
+
+```sh
+npm install
+npm run dev
+```
+
+Open http://localhost:3278. Use PORT and HOST to override the defaults.
+
+## Commands
+
+- `npm run check`: generate routes and validate types and Angular templates.
+- `npm run build`: build the Node server, client assets and prerendered pages.
+- `npm start`: run the production server.
+- `npm run build:vercel`: generate the Vercel Build Output API directory.
+
+## Application files
+
+- `src/app/pages`: Angular pages and adjacent route metadata.
+- `src/server/api`: Fastify endpoints; the filename selects the HTTP method.
+- `src/server/plugins.ts`: Fastify hooks and plugins.
+- `fastang.config.ts`: explicit prerender URLs and Vercel function configuration.
+
+The home page includes an interactive counter. `/greet/world` resolves data from
+`/api/greet/world` during SSR and uses Angular's HTTP transfer cache during
+hydration. `/about` is prerendered. Unknown pages return HTTP 404.
+
+For Vercel use the Other preset, build command `npm run build:vercel`, and no
+output-directory override. `vercel.json` already contains the build settings.

package/template/_gitignore

@@ -0,0 +1,9 @@
+node_modules/
+dist/
+.fastang/
+.angular/
+.vercel/
+src/app/fastang.routes.ts
+.env
+.env.*
+!.env.example

package/template/fastang.config.ts

@@ -0,0 +1,2 @@
+import { defineConfig } from '@fastang/core';
+export default defineConfig({ prerender: ['/about'], vercel: { functions: 'routes' } });

package/template/index.html

@@ -0,0 +1,2 @@
+<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><base href="/"><meta name="viewport" content="width=device-width, initial-scale=1"><title>FastAng starter</title></head><body><app-root></app-root><script type="module" src="/src/main.ts"></script></body></html>

package/template/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "fastang-starter",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "engines": {
+    "node": "^22.22.3 || ^24.15.0 || >=26.0.0"
+  },
+  "scripts": {
+    "dev": "fastang dev",
+    "generate": "fastang generate",
+    "check": "fastang generate && ngc -p tsconfig.app.json --noEmit && tsc -p tsconfig.node.json --noEmit",
+    "build": "npm run check && fastang build",
+    "build:vercel": "npm run check && fastang build --vercel",
+    "start": "node dist/server/index.js"
+  },
+  "dependencies": {
+    "@angular/common": "22.2.3",
+    "@angular/compiler": "22.2.3",
+    "@angular/core": "22.2.3",
+    "@angular/platform-browser": "22.2.3",
+    "@angular/platform-server": "22.2.3",
+    "@angular/router": "22.2.3",
+    "fastify": "^5.12.7",
+    "rxjs": "^7.8.2",
+    "tslib": "^2.8.1",
+    "@fastang/core": "0.1.0-alpha.1"
+  },
+  "devDependencies": {
+    "@angular/build": "22.2.3",
+    "@angular/compiler-cli": "22.2.3",
+    "@types/node": "^22.19.0",
+    "typescript": "~6.0.2",
+    "vite": "8.3.4"
+  }
+}

package/template/src/app/app.config.ts

@@ -0,0 +1,8 @@
+import type { ApplicationConfig } from '@angular/core';
+import { provideHttpClient, withFetch } from '@angular/common/http';
+import { provideClientHydration, withEventReplay } from '@angular/platform-browser';
+import { provideRouter, withComponentInputBinding } from '@angular/router';
+import { createRoutes } from './fastang.routes';
+export function createAppConfig(): ApplicationConfig {
+  return { providers: [provideRouter(createRoutes(), withComponentInputBinding()), provideHttpClient(withFetch()), provideClientHydration(withEventReplay())] };
+}

package/template/src/app/app.ts

@@ -0,0 +1,7 @@
+import { Component } from '@angular/core';
+import { RouterLink, RouterOutlet } from '@angular/router';
+@Component({ selector: 'app-root', imports: [RouterLink, RouterOutlet], template: `
+  <header><a routerLink="/">FastAng</a><nav><a routerLink="/about">About</a><a routerLink="/greet/world">SSR + API</a></nav></header>
+  <main><router-outlet /></main>
+` })
+export class App {}

package/template/src/app/omitted.server.ts

@@ -0,0 +1,14 @@
+import { Component, REQUEST_CONTEXT, inject } from '@angular/core';
+import { RouterOutlet } from '@angular/router';
+import type { RenderContext } from '@fastang/core';
+
+/** Redirect destinations can be resolved without bundling their page templates. */
+@Component({ selector: 'fastang-omitted-route', imports: [RouterOutlet], template: '<router-outlet />' })
+export default class OmittedRoute {
+  constructor() {
+    const context = inject(REQUEST_CONTEXT) as RenderContext | null;
+    // A redirect takes precedence over status in the HTTP bridge. An unexpected
+    // direct invocation must never turn an omitted page into a blank HTTP 200.
+    if (context) context.status = 404;
+  }
+}

package/template/src/app/pages/[...slug].page.ts

@@ -0,0 +1,7 @@
+import { Component, REQUEST_CONTEXT, inject } from '@angular/core';
+import { RouterLink } from '@angular/router';
+import type { RenderContext } from '@fastang/core';
+@Component({ imports: [RouterLink], template: `<h1>Page not found</h1><a routerLink="/">Back home</a>` })
+export default class NotFoundPage {
+  constructor() { const context = inject(REQUEST_CONTEXT) as RenderContext | null; if (context) context.status = 404; }
+}

package/template/src/app/pages/[...slug].route.ts

@@ -0,0 +1 @@
+export default { title: 'Page not found · FastAng' };

package/template/src/app/pages/about.page.ts

@@ -0,0 +1,3 @@
+import { Component } from '@angular/core';
+@Component({ template: `<p class="eyebrow">PRERENDERED</p><h1>Built ahead of time.</h1><p>This page is generated during the build. Choose public URLs in fastang.config.ts.</p>` })
+export default class AboutPage {}

package/template/src/app/pages/about.route.ts

@@ -0,0 +1 @@
+export default { title: 'About · FastAng' };

package/template/src/app/pages/greet/[name].page.ts

@@ -0,0 +1,3 @@
+import { Component, input } from '@angular/core';
+@Component({ template: `<p class="eyebrow">SERVER RENDERED</p><h1>{{ greeting().message }}</h1><p>The Angular resolver calls a validated Fastify endpoint. Hydration reuses its response.</p>` })
+export default class GreetingPage { readonly greeting = input.required<{ message: string }>(); }

package/template/src/app/pages/greet/[name].route.ts

@@ -0,0 +1,5 @@
+import { inject } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import type { ResolveFn } from '@angular/router';
+const greeting: ResolveFn<{ message: string }> = route => inject(HttpClient).get<{ message: string }>('/api/greet/' + encodeURIComponent(route.paramMap.get('name')!));
+export default { title: 'Greeting · FastAng', resolve: { greeting } };

package/template/src/app/pages/index.page.ts

@@ -0,0 +1,12 @@
+import { Component, signal } from '@angular/core';
+import { RouterLink } from '@angular/router';
+@Component({ imports: [RouterLink], template: `
+  <p class="eyebrow">ANGULAR + FASTIFY</p><h1>Your next idea starts here.</h1>
+  <p>Angular pages, Fastify APIs and server rendering in one project.</p>
+  <p><a routerLink="/greet/world">Try a server-rendered API response →</a></p>
+  <button (click)="count.update(increment)">Clicked {{ count() }} {{ count() === 1 ? 'time' : 'times' }}</button>
+` })
+export default class HomePage {
+  readonly count = signal(0);
+  readonly increment = (value: number) => value + 1;
+}

package/template/src/app/pages/index.route.ts

@@ -0,0 +1 @@
+export default { title: 'Home · FastAng' };

package/template/src/main.server.ts

@@ -0,0 +1,5 @@
+import { createRenderer } from '@fastang/core/angular';
+import { App } from './app/app';
+import { createAppConfig } from './app/app.config';
+
+export const render = createRenderer(App, createAppConfig);

package/template/src/main.ts

@@ -0,0 +1,6 @@
+import { bootstrapApplication } from '@angular/platform-browser';
+import { App } from './app/app';
+import { createAppConfig } from './app/app.config';
+import './styles.css';
+
+bootstrapApplication(App, createAppConfig()).catch(console.error);

package/template/src/server/api/greet/[name].get.ts

@@ -0,0 +1,8 @@
+import { defineApiRoute } from '@fastang/core';
+export default defineApiRoute<{ Params: { name: string } }>({
+  schema: {
+    params: { type: 'object', required: ['name'], properties: { name: { type: 'string', minLength: 1, maxLength: 80 } } },
+    response: { 200: { type: 'object', required: ['message'], properties: { message: { type: 'string' } } } },
+  },
+  handler: async request => ({ message: `Hello, ${request.params.name}!` }),
+});

package/template/src/server/api/health.get.ts

@@ -0,0 +1,2 @@
+import { defineApiRoute } from '@fastang/core';
+export default defineApiRoute({ schema: { response: { 200: { type: 'object', required: ['ok'], properties: { ok: { type: 'boolean' } } } } }, handler: async () => ({ ok: true }) });

package/template/src/server/api-entry.ts

@@ -0,0 +1,7 @@
+import { createApiServer } from '@fastang/core/server';
+import { createNodeHandler } from '@fastang/core/node-handler';
+import { configureServer } from './plugins';
+import { registerApi } from '../../.fastang/api';
+
+// This entry point deliberately has no Angular renderer dependency.
+export default createNodeHandler(() => createApiServer({ configure: configureServer, registerApi }));

package/template/src/server/index.ts

@@ -0,0 +1,19 @@
+import { readFile } from 'node:fs/promises';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createServer } from '@fastang/core/server';
+import { render } from '../main.server';
+import { configureServer } from './plugins';
+import { registerApi } from '../../.fastang/api';
+
+const directory = dirname(fileURLToPath(import.meta.url));
+export async function createProductionServer(options: { prerender?: boolean; logger?: boolean; serveAssets?: boolean } = {}) {
+  const clientDir = resolve(directory, '../client');
+  const document = await readFile(resolve(clientDir, 'index.html'), 'utf8');
+  const prerendered: string[] = options.prerender === false ? [] : JSON.parse(await readFile(resolve(directory, '../prerender.json'), 'utf8'));
+  return createServer({
+    logger: options.logger ?? false,
+    clientDir: options.serveAssets === false ? undefined : clientDir, prerendered,
+    template: async () => document, render, configure: configureServer, registerApi,
+  });
+}

package/template/src/server/plugins.ts

@@ -0,0 +1,2 @@
+import type { FastifyInstance } from 'fastify';
+export async function configureServer(_app: FastifyInstance): Promise<void> {}

package/template/src/server/start.ts

@@ -0,0 +1,11 @@
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { listen } from '@fastang/core/listen';
+import { createProductionServer } from './index';
+
+export { createProductionServer };
+
+// Kept in the executable entry, so code splitting cannot move this check to a shared chunk.
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  await listen(await createProductionServer({ logger: true }));
+}

package/template/src/server/vercel-entry.ts

@@ -0,0 +1,5 @@
+import { createNodeHandler } from '@fastang/core/node-handler';
+import { createProductionServer } from './index';
+
+// Static files and prerendered pages are handled by Vercel's CDN.
+export default createNodeHandler(() => createProductionServer({ prerender: false, serveAssets: false }));

package/template/src/styles.css

@@ -0,0 +1,7 @@
+:root { color-scheme: dark; font-family: system-ui, sans-serif; background: #11131a; color: #f3f4f8; }
+body { margin: 0; } header, main { max-width: 58rem; margin: auto; padding: 2rem; }
+header { display: flex; justify-content: space-between; border-bottom: 1px solid #34394b; }
+nav { display: flex; gap: 1.5rem; } main { padding-top: 5rem; } a { color: #a6b9ff; }
+h1 { font-size: clamp(2rem, 6vw, 4rem); letter-spacing: -.04em; line-height: 1.1; }
+p { max-width: 42rem; line-height: 1.7; } .eyebrow { font-size: .8rem; letter-spacing: .16em; color: #a6b9ff; }
+button { margin-top: 1rem; padding: .8rem 1.1rem; font: inherit; border-radius: .5rem; border: 1px solid #879deb; color: #fff; background: #334b9d; cursor: pointer; }

package/template/tsconfig.app.json

@@ -0,0 +1,14 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./.fastang/tsc",
+    "types": ["vite/client"],
+    "declaration": false
+  },
+  "angularCompilerOptions": {
+    "strictTemplates": true,
+    "strictInjectionParameters": true,
+    "strictInputAccessModifiers": true
+  },
+  "include": ["src/app/**/*.ts", "src/shared/**/*.ts", "src/main.ts", "src/main.server.ts"]
+}

package/template/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": [
+      "ES2022",
+      "DOM"
+    ],
+    "strict": true,
+    "skipLibCheck": true,
+    "experimentalDecorators": true,
+    "importHelpers": true,
+    "isolatedModules": true,
+    "verbatimModuleSyntax": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "noFallthroughCasesInSwitch": true,
+    "allowImportingTsExtensions": true
+  }
+}

package/template/tsconfig.node.json

@@ -0,0 +1,16 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "types": [
+      "node",
+      "vite/client"
+    ],
+    "noEmit": true
+  },
+  "include": [
+    "src/server/**/*.ts",
+    "src/shared/**/*.ts",
+    "fastang.config.ts",
+    "vite.config.ts"
+  ]
+}

package/template/vercel.json

@@ -0,0 +1,5 @@
+{
+  "$schema": "https://openapi.vercel.sh/vercel.json",
+  "framework": null,
+  "buildCommand": "npm run build:vercel"
+}

package/template/vite.config.ts

@@ -0,0 +1,2 @@
+import { defineFastangConfig } from '@fastang/core/vite';
+export default defineFastangConfig();