create-upwind 0.2.0

package/src/create.ts

@@ -0,0 +1,123 @@
+import path from 'node:path';
+
+import type { CreateRequest } from './args.ts';
+import { initRepository } from './git.ts';
+import { writeManifest } from './manifest.ts';
+import { nameProblem } from './name.ts';
+import {
+  detectPackageManager,
+  install,
+  type PackageManager,
+  runCommand,
+} from './package-manager.ts';
+import { askDirectory } from './prompt.ts';
+import { conflictsIn, copyTemplate, retellReadme } from './template.ts';
+
+/**
+ * One run: a directory with a Next.js application in it that upwind can run.
+ *
+ * The order is the order a developer would do it in. Everything that can be refused is refused
+ * before anything is written — a name npm would not take, a directory with something in it — so a
+ * run either leaves an application or leaves nothing.
+ *
+ * The install comes before the first commit so the lockfile is in it: the point of a lockfile is the
+ * install somebody else does from it, and one that arrives a commit late is one that arrives after
+ * the first person cloned it.
+ */
+
+const DEFAULT_DIRECTORY = 'my-upwind-app';
+/** How many of the things in the way to name before saying "and others". */
+const CONFLICTS_SHOWN = 5;
+
+function refuseConflicts(target: string, conflicts: readonly string[]): never {
+  const shown = conflicts.slice(0, CONFLICTS_SHOWN).join(', ');
+  const rest =
+    conflicts.length > CONFLICTS_SHOWN ? `, and ${conflicts.length - CONFLICTS_SHOWN} more` : '';
+  throw new Error(`${target} already has something in it (${shown}${rest})`);
+}
+
+/** How a single quote is written inside single quotes: close, escape one, open again. */
+const ESCAPED_QUOTE = String.raw`'\''`;
+/** What needs no quoting anywhere, plus the separator each shell writes a path with. */
+const PLAIN = process.platform === 'win32' ? /^[\w+,.:=@\\-]+$/u : /^[\w+,./:=@-]+$/u;
+
+/**
+ * A path the shell this was run from reads as one word, and as a path.
+ *
+ * Two things can go wrong with a next step somebody pastes. A path with a space in it is two
+ * arguments — and `cmd.exe` does not read the single quotes a POSIX shell does, so the quoting has
+ * to be the one the platform uses. And a relative path that begins with `-` is read as options by
+ * every shell there is, which `./` settles.
+ *
+ * Two things are left, and both are `cmd.exe`'s alone. It expands `%NAME%` inside double quotes and
+ * has no escape for it at the prompt, so a directory with a percent sign in its name prints a line
+ * that reads as something else there. And a target on another drive needs `cd /d` there, which is
+ * not a `cd` PowerShell accepts. Both read correctly in PowerShell, which is where a Windows
+ * developer is more likely to be standing, and the alternative would be a line that is wrong in the
+ * other shell instead.
+ */
+function shellWord(value: string): string {
+  const safe = value.startsWith('-') ? `./${value}` : value;
+  if (PLAIN.test(safe)) {
+    return safe;
+  }
+  return process.platform === 'win32'
+    ? `"${safe}"`
+    : `'${safe.replaceAll("'", () => ESCAPED_QUOTE)}'`;
+}
+
+function printNextSteps(options: {
+  readonly target: string;
+  readonly manager: PackageManager;
+  readonly committed: boolean;
+  readonly installed: boolean;
+}): void {
+  const { manager, target } = options;
+  const where = path.relative(process.cwd(), target);
+  const dev = runCommand(manager, 'dev');
+  console.log('');
+  console.log(
+    `Created ${path.basename(target)}${options.committed ? ' with a first commit' : ''}.`,
+  );
+  console.log('');
+  if (where !== '') {
+    console.log(`  cd ${shellWord(where)}`);
+  }
+  if (!options.installed) {
+    // Nothing was installed, so `dev` would be a command that is not there yet.
+    console.log(`  ${manager} install`);
+  }
+  console.log(`  ${dev}`);
+  console.log('');
+  console.log(
+    `\`${dev}\` runs upwind in front of the project's own Next.js, and /__upwind is answered by`,
+  );
+  console.log(
+    `upwind itself. \`${runCommand(manager, 'build')}\` writes the deployment bundle under .ppr-cdn/.`,
+  );
+}
+
+export async function create(request: CreateRequest): Promise<void> {
+  const directory = request.directory ?? (await askDirectory(DEFAULT_DIRECTORY));
+  const target = path.resolve(directory);
+  const name = path.basename(target);
+  const problem = nameProblem(name);
+  if (problem !== undefined) {
+    throw new Error(`\`${name}\` ${problem}`);
+  }
+  const conflicts = await conflictsIn(target);
+  if (conflicts.length > 0) {
+    refuseConflicts(target, conflicts);
+  }
+  const manager = request.packageManager ?? detectPackageManager();
+  console.log(`Creating ${name} in ${target}`);
+  await copyTemplate(target);
+  await retellReadme(target, manager);
+  await writeManifest(target, name);
+  if (request.install) {
+    console.log('');
+    await install(manager, target);
+  }
+  const committed = request.git && (await initRepository(target));
+  printNextSteps({ target, manager, committed, installed: request.install });
+}

package/src/git.ts

@@ -0,0 +1,75 @@
+import { spawn } from 'node:child_process';
+import { once } from 'node:events';
+import { lstat, rm } from 'node:fs/promises';
+import path from 'node:path';
+
+/**
+ * A first commit, where there is a repository to be made.
+ *
+ * Never fatal. A machine with no git, a git with no identity configured, a directory already inside
+ * somebody's repository: none of those is a reason to have failed to scaffold an application, and
+ * all of them are things a developer can see for themselves. A repository this started and could not
+ * finish is removed again, so what is left is either a clean first commit or no `.git` at all.
+ */
+
+const FIRST_COMMIT = 'Initial commit from create-upwind';
+
+/** Run git, quietly; `undefined` when git itself is not there. */
+async function git(args: readonly string[], cwd: string): Promise<number | undefined> {
+  const child = spawn('git', args, { cwd, stdio: 'ignore' });
+  try {
+    const [code] = (await once(child, 'exit')) as [number | null, NodeJS.Signals | null];
+    return code ?? 1;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Is this directory already part of a repository? Then its history is not this program's to start. */
+async function insideRepository(cwd: string): Promise<boolean> {
+  return (await git(['rev-parse', '--is-inside-work-tree'], cwd)) === 0;
+}
+
+/**
+ * Does the target already hold a checkout of its own? Then nothing here is this program's.
+ *
+ * `lstat`, not `stat`: a `.git` that is a symlink — dangling, or pointing at a repository somewhere
+ * else — is still an entry this program did not put there. Following it would answer "nothing here"
+ * for a broken one, and `git init` would then write through it, into a directory nobody named.
+ */
+async function hasGitEntry(target: string): Promise<boolean> {
+  try {
+    await lstat(path.join(target, '.git'));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** True when a repository was made and committed to. */
+export async function initRepository(target: string): Promise<boolean> {
+  // Asked before anything: a `.git` that was already there is somebody's history, whatever git says
+  // about it. `rev-parse` can refuse a repository it will not touch — a checkout owned by another
+  // user is the usual one — and an `init` after that answer would re-initialize the repository this
+  // program would then delete in its own cleanup, remotes, config, history and all.
+  if ((await hasGitEntry(target)) || (await insideRepository(target))) {
+    return false;
+  }
+  if ((await git(['init', '-b', 'main'], target)) !== 0) {
+    return false;
+  }
+  const added = await git(['add', '-A'], target);
+  const committed = added === 0 ? await git(['commit', '-m', FIRST_COMMIT], target) : undefined;
+  if (committed === 0) {
+    return true;
+  }
+  // Half a repository is worse than none: an `init` nobody asked to be left behind — and one this
+  // run made, which is what the check above is for. A cleanup that cannot be done is still not a
+  // reason to have failed to write an application; this answers "no repository" either way.
+  try {
+    await rm(path.join(target, '.git'), { recursive: true, force: true });
+  } catch {
+    // Nothing to do about it here, and nothing that depends on it.
+  }
+  return false;
+}

package/src/manifest.ts

@@ -0,0 +1,70 @@
+import { writeFile } from 'node:fs/promises';
+import path from 'node:path';
+
+import { ownRange } from './version.ts';
+
+/**
+ * The `package.json` a scaffolded project starts with.
+ *
+ * Written rather than shipped in the template, so the name is the directory's and the versions are
+ * this release's. Two of them are the whole point of the file:
+ *
+ * - **`next`, `react`, `react-dom` are dependencies, not suggestions.** upwind runs the *project's*
+ *   Next.js — `upwind dev` resolves it from the project and refuses to start without it — so an
+ *   application that upwind can run is one that has Next.js of its own.
+ * - **`upwind` and the adapter come from this release.** `create-upwind@x.y.z` asks for `^x.y.z` of
+ *   both, and the release publishes them from one tag, so a scaffolded project is wired to the
+ *   generation that scaffolded it.
+ *
+ * The rest is what Next.js 16 and Tailwind 4 need, and nothing else: no ESLint, no `src/`, no
+ * component library. `create-next-app --empty` is the shape.
+ */
+
+/**
+ * What the template is written against.
+ *
+ * `next` is a caret on the version this repository builds against, and stays inside
+ * `SUPPORTED_NEXT_RANGE` (`@stayingupwind/adapter`'s `patches/versions.ts`), which is what the
+ * adapter's patches are held to. A release that moves that range moves this line with it.
+ */
+const VERSIONS = {
+  '@tailwindcss/postcss': '^4.3.3',
+  '@types/node': '^24.13.4',
+  '@types/react': '^19.3.0',
+  '@types/react-dom': '^19.3.0',
+  next: '^16.3.6',
+  react: '^19.3.0',
+  'react-dom': '^19.3.0',
+  tailwindcss: '^4.3.3',
+  typescript: '^5.9.3',
+} as const;
+
+export async function writeManifest(target: string, name: string): Promise<void> {
+  const upwind = await ownRange();
+  const manifest = {
+    name,
+    version: '0.1.0',
+    // Nothing here is meant for a registry, and npm refuses to publish what says so.
+    private: true,
+    scripts: {
+      dev: 'upwind dev',
+      build: 'upwind build',
+    },
+    dependencies: {
+      next: VERSIONS.next,
+      react: VERSIONS.react,
+      'react-dom': VERSIONS['react-dom'],
+    },
+    devDependencies: {
+      '@stayingupwind/adapter': upwind,
+      '@tailwindcss/postcss': VERSIONS['@tailwindcss/postcss'],
+      '@types/node': VERSIONS['@types/node'],
+      '@types/react': VERSIONS['@types/react'],
+      '@types/react-dom': VERSIONS['@types/react-dom'],
+      tailwindcss: VERSIONS.tailwindcss,
+      typescript: VERSIONS.typescript,
+      upwind,
+    },
+  };
+  await writeFile(path.join(target, 'package.json'), `${JSON.stringify(manifest, null, 2)}\n`);
+}

package/src/name.ts

@@ -0,0 +1,40 @@
+/**
+ * The name a scaffolded project takes, which is the directory it was asked for.
+ *
+ * npm's rules, as far as one matters here: the manifest this writes is `private`, so nothing will
+ * ever publish it — but a name npm refuses is one that `npm install` inside the project refuses too,
+ * and finding that out on the first install is worse than finding it out now.
+ *
+ * `validate-npm-package-name` is the package that knows all of them. It is not a dependency here for
+ * the same reason nothing else is: this runs once, from a registry, in somebody else's shell.
+ */
+
+/** npm's own limit. */
+const MAX_LENGTH = 214;
+/** What an unscoped name may be made of, as the registry accepts it. */
+const ALLOWED = /^[a-z0-9._~-]+$/u;
+/** The two names npm refuses outright, whatever else is true of them. */
+const REFUSED: ReadonlySet<string> = new Set(['favicon.ico', 'node_modules']);
+
+/** What is wrong with `name` as a package name, or nothing when it is a fine one. */
+export function nameProblem(name: string): string | undefined {
+  if (name === '') {
+    return 'is empty';
+  }
+  if (REFUSED.has(name)) {
+    return 'is a name npm will not take, whatever is in the directory';
+  }
+  if (name.length > MAX_LENGTH) {
+    return `is longer than npm's ${MAX_LENGTH} characters`;
+  }
+  if (name !== name.toLowerCase()) {
+    return 'has capital letters, which npm does not allow in a package name';
+  }
+  if (name.startsWith('.') || name.startsWith('_')) {
+    return 'starts with a dot or an underscore, which npm does not allow in a package name';
+  }
+  if (!ALLOWED.test(name)) {
+    return 'has characters npm does not allow in a package name (letters, digits, `.`, `-`, `_` and `~`)';
+  }
+  return undefined;
+}

package/src/package-manager.ts

@@ -0,0 +1,70 @@
+import { spawn } from 'node:child_process';
+import { once } from 'node:events';
+
+/**
+ * Which package manager scaffolded this, and the install it runs.
+ *
+ * `pnpm create upwind`, `npm create upwind`, `yarn create upwind` and `bun create upwind` all reach
+ * this same program, and the one thing they leave behind to say which they were is
+ * `npm_config_user_agent`. A project installed with the manager its author started from is one whose
+ * lockfile is the one they expect.
+ */
+
+export const PACKAGE_MANAGERS = ['npm', 'pnpm', 'yarn', 'bun'] as const;
+export type PackageManager = (typeof PACKAGE_MANAGERS)[number];
+
+/** `pnpm/12.4.1 npm/? node/? linux x64` — the name is everything before the first slash. */
+export function detectPackageManager(): PackageManager {
+  const agent = process.env['npm_config_user_agent'] ?? '';
+  const [name] = agent.split('/', 1);
+  const known = PACKAGE_MANAGERS.find((manager) => manager === name);
+  return known ?? 'npm';
+}
+
+/** The application is on disk by now, whatever went wrong here; say so, and say what to do. */
+function refuse(manager: PackageManager, why: string): never {
+  throw new Error(
+    `${why}. The application is written; run \`${manager} install\` in it once you know why.`,
+  );
+}
+
+export async function install(manager: PackageManager, cwd: string): Promise<void> {
+  const child = spawn(manager, ['install'], {
+    cwd,
+    stdio: 'inherit',
+    // Windows reaches `pnpm.cmd` and friends through the shell and not otherwise.
+    //
+    // Elsewhere in this repository a command is named for the platform instead — `npm.cmd` on
+    // Windows — and started without one, because what those pass on the line is a version string
+    // read off a registry. This passes the word `install` and nothing else, and the command is one
+    // of four names of this program's own choosing; and of those four, `bun` is on PATH as an
+    // `.exe` or a `.cmd` depending on how it was installed, which no single name covers. So the
+    // shell here is what finds the launcher, and it is handed nothing to interpret.
+    shell: process.platform === 'win32',
+  });
+  let code;
+  try {
+    [code] = (await once(child, 'exit')) as [number | null, NodeJS.Signals | null];
+  } catch {
+    // `events.once` rejects on `error`, which is what a command that is not on the PATH raises — a
+    // `--use-bun` on a machine with no bun. The raw `spawn bun ENOENT` says less than this does.
+    refuse(manager, `\`${manager}\` could not be run; it may not be installed`);
+  }
+  if (code !== 0) {
+    refuse(manager, `\`${manager} install\` failed`);
+  }
+}
+
+/** The two the bare word does not reach a project script through. */
+const NEEDS_RUN: ReadonlySet<PackageManager> = new Set<PackageManager>(['bun', 'npm']);
+
+/**
+ * How a developer runs one of the project's scripts with this manager.
+ *
+ * `npm dev` is not a command at all, and `bun build` is a different one: Bun's own bundler, which
+ * answers a project's `build` script with "Missing entrypoints". Both take `run`. `pnpm` and `yarn`
+ * pass an unknown word to the scripts, and `pnpm run dev` would only be longer.
+ */
+export function runCommand(manager: PackageManager, script: string): string {
+  return NEEDS_RUN.has(manager) ? `${manager} run ${script}` : `${manager} ${script}`;
+}

package/src/prompt.ts

@@ -0,0 +1,61 @@
+import { once } from 'node:events';
+import { createInterface, type Interface } from 'node:readline/promises';
+
+/**
+ * The one question this asks.
+ *
+ * One, because there is one template: everything else a scaffolder usually asks — TypeScript, the
+ * router, the bundler — is already decided by what upwind runs. A question with one possible answer
+ * is a keystroke taken from someone who typed `pnpm create upwind` to get an application.
+ *
+ * Asked only of a terminal. `pnpm create upwind < /dev/null`, or the same from a script or a CI job,
+ * takes the default rather than waiting for an answer that is never coming — a scaffolder that hangs
+ * on a closed stdin is one that hangs a pipeline.
+ */
+
+/** The default is what an empty answer means, and Ctrl-D is the emptiest answer there is. */
+const NO_ANSWER = '';
+
+/** The answer an input that closed without one gives. */
+async function untilClosed(rl: Interface): Promise<string> {
+  await once(rl, 'close');
+  return NO_ANSWER;
+}
+
+/**
+ * The answer, or none.
+ *
+ * Ctrl-D does not answer the question, it abandons it: Node rejects the promise with an
+ * `AbortError` — "Aborted with Ctrl+D" — rather than resolving it with nothing. Caught here, because
+ * an input that has ended has no more answers to give, and the one this asks for has a default.
+ */
+async function askOnce(rl: Interface, prompt: string): Promise<string> {
+  try {
+    return await rl.question(prompt);
+  } catch {
+    return NO_ANSWER;
+  }
+}
+
+export async function askDirectory(fallback: string): Promise<string> {
+  if (!process.stdin.isTTY) {
+    return fallback;
+  }
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  // `using` is not erasable syntax, and the lib this is typed against has no `Symbol.dispose`.
+  // eslint-disable-next-line unicorn/prefer-dispose -- see above
+  try {
+    // An input that ends means the default, whichever way it ends: `askOnce` catches the rejection
+    // Ctrl-D raises, and the race catches a close that leaves the question unanswered and
+    // unrejected. Either way this returns, because a scaffolder that ends having written nothing is
+    // not an answer to `pnpm create upwind`.
+    const answer = await Promise.race([
+      askOnce(rl, `Where should the application go? (${fallback}) `),
+      untilClosed(rl),
+    ]);
+    const trimmed = answer.trim();
+    return trimmed === NO_ANSWER ? fallback : trimmed;
+  } finally {
+    rl.close();
+  }
+}

package/src/template.ts

@@ -0,0 +1,69 @@
+import { cp, readdir, readFile, rename, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { type PackageManager, runCommand } from './package-manager.ts';
+
+/**
+ * The application this copies, and what has to be renamed on the way out.
+ *
+ * `../templates/default/` reads the same from the sources a workspace links and from the module a
+ * registry installs: both sit one directory below the package root, and `templates` travels with the
+ * package (`files`).
+ *
+ * The template carries `gitignore` without its dot because **npm removes a `.gitignore` from every
+ * tarball it packs**. A template that kept the dot would arrive with no ignore file at all, and the
+ * first commit of every scaffolded project would carry `node_modules`. `create-next-app` renames the
+ * same file for the same reason.
+ */
+const TEMPLATE = fileURLToPath(new URL('../templates/default/', import.meta.url));
+
+/** Entries that do not make a directory non-empty: a checkout and a Finder artefact. */
+const IGNORED_ENTRIES: ReadonlySet<string> = new Set(['.DS_Store', '.git']);
+
+/** Is this the error of a directory that is not there? Anything else is a directory that is. */
+function isMissing(error: unknown): boolean {
+  return typeof error === 'object' && error !== null && 'code' in error && error.code === 'ENOENT';
+}
+
+/** What is already in the way, if anything: the names, so the message can say them. */
+export async function conflictsIn(target: string): Promise<readonly string[]> {
+  try {
+    const entries = await readdir(target);
+    return entries.filter((entry) => !IGNORED_ENTRIES.has(entry));
+  } catch (error) {
+    if (isMissing(error)) {
+      // Nothing there to conflict with; `cp` makes the directory.
+      return [];
+    }
+    // A directory that cannot be read is not an empty one. Taking it for empty would write an
+    // application into a place this could not even look at first.
+    throw error;
+  }
+}
+
+export async function copyTemplate(target: string): Promise<void> {
+  await cp(TEMPLATE, target, { recursive: true });
+  await rename(path.join(target, 'gitignore'), path.join(target, '.gitignore'));
+}
+
+/**
+ * The README, in the manager the project was made with.
+ *
+ * The template is written in pnpm because a file has to be written in something. A project installed
+ * with npm has an npm lockfile, and a README that tells its reader to run pnpm tells them to install
+ * it a second way — or, on a machine without pnpm, to run something that is not there.
+ */
+export async function retellReadme(target: string, manager: PackageManager): Promise<void> {
+  if (manager === 'pnpm') {
+    return;
+  }
+  const readme = path.join(target, 'README.md');
+  const written = await readFile(readme, 'utf8');
+  // Replacement functions, not strings: what a manager's command is has no `$` in it, and a
+  // replacement that is taken for a pattern is a bug nobody would look for here.
+  const retold = written
+    .replaceAll('pnpm dev', () => runCommand(manager, 'dev'))
+    .replaceAll('pnpm build', () => runCommand(manager, 'build'));
+  await writeFile(readme, retold);
+}

package/src/version.ts

@@ -0,0 +1,36 @@
+import { readFile } from 'node:fs/promises';
+
+/**
+ * This scaffolder's own version, and what it asks for of the packages released beside it.
+ *
+ * `create-upwind@x.y.z` scaffolds `upwind@^x.y.z`: the two are published from one tag, which the
+ * release verifies says the version every package says, so a scaffolder and the CLI it wires in are
+ * always of the same generation. A version that cannot be read falls back to `latest` — a scaffolded
+ * project that installs the newest is a better answer than one that installs nothing.
+ */
+const FALLBACK = 'latest';
+
+export async function ownRange(): Promise<string> {
+  try {
+    const manifest: unknown = JSON.parse(
+      await readFile(new URL('../package.json', import.meta.url), 'utf8'),
+    );
+    if (
+      typeof manifest === 'object' &&
+      manifest !== null &&
+      'version' in manifest &&
+      typeof manifest.version === 'string'
+    ) {
+      return `^${manifest.version}`;
+    }
+    return FALLBACK;
+  } catch {
+    return FALLBACK;
+  }
+}
+
+/** The version this reports for `--version`, or nothing when its own manifest could not be read. */
+export async function ownVersion(): Promise<string | undefined> {
+  const range = await ownRange();
+  return range === FALLBACK ? undefined : range.slice(1);
+}

package/templates/default/README.md

@@ -0,0 +1,47 @@
+# upwind app
+
+A [Next.js](https://nextjs.org) application, run by [upwind](https://github.com/arkorlab/upwind).
+
+```bash
+pnpm dev
+```
+
+`pnpm dev` is `upwind dev`: upwind holds the port and hands every request to the project's own
+Next.js development server — the same dev bundler, the same HMR, the same error overlay — except for
+`/__upwind`, which upwind answers itself. Open
+[http://localhost:3000/__upwind](http://localhost:3000/__upwind) to see what it says about the run;
+it answers while the application is still compiling, and while a compile of it is failing.
+
+Edit `app/page.tsx` and the page updates.
+
+## Building
+
+```bash
+pnpm build
+```
+
+`pnpm build` is `upwind build`: the project's own `next build`, with the deployment adapter named. It
+writes a deployment bundle under `.ppr-cdn/` — every route, prerender and static file by content,
+and the Functions that run the application's code. `next.config.ts` names the same adapter, so a
+plain `next build` from CI or from any other tool produces the same bundle.
+
+There is no `start` script on purpose. What a deployment runs is the bundle, not a Node server of
+this project's own.
+
+## Scheduled work
+
+Cron jobs are declared beside `next.config.ts`, in an `upwind.config.ts` (or `upwind.json`) of your
+own:
+
+```ts
+export default {
+  crons: [{ path: '/api/nightly', schedule: '0 3 * * *' }],
+};
+```
+
+The build reads it, refuses a schedule it cannot run, and carries what it accepted into the bundle.
+
+## Learn more
+
+- [Next.js documentation](https://nextjs.org/docs)
+- [Tailwind CSS](https://tailwindcss.com/docs) — already set up, in `app/globals.css`

package/templates/default/app/globals.css

@@ -0,0 +1 @@
+@import "tailwindcss";

package/templates/default/app/layout.tsx

@@ -0,0 +1,16 @@
+import type { Metadata } from 'next';
+
+import './globals.css';
+
+export const metadata: Metadata = {
+  title: 'upwind app',
+  description: 'A Next.js application, run by upwind.',
+};
+
+export default function RootLayout({ children }: Readonly<{ children: React.ReactNode }>) {
+  return (
+    <html lang="en">
+      <body className="antialiased">{children}</body>
+    </html>
+  );
+}

package/templates/default/app/page.tsx

@@ -0,0 +1,13 @@
+export default function Home() {
+  return (
+    <main className="flex min-h-screen flex-col items-center justify-center gap-4 p-8">
+      <h1 className="text-2xl font-semibold">upwind</h1>
+      <p className="text-sm text-gray-500">
+        Edit <code className="font-mono">app/page.tsx</code> to get started.
+      </p>
+      <a className="text-sm underline underline-offset-4" href="/__upwind">
+        /__upwind
+      </a>
+    </main>
+  );
+}

package/templates/default/gitignore

@@ -0,0 +1,33 @@
+# dependencies
+/node_modules
+/.pnp
+.pnp.*
+.yarn/*
+!.yarn/patches
+!.yarn/plugins
+!.yarn/releases
+!.yarn/versions
+
+# next.js
+/.next/
+/out/
+
+# the deployment bundle a build writes
+/.ppr-cdn/
+
+# misc
+.DS_Store
+*.pem
+
+# debug
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+.pnpm-debug.log*
+
+# env files
+.env*
+
+# typescript
+*.tsbuildinfo
+next-env.d.ts