@rivetjs/nx 0.0.0-stage → 0.1.0-alpha.0

package/executors/run.d.ts

@@ -0,0 +1,33 @@
+import { type ChildProcess } from "node:child_process";
+import type { ExecutorContext } from "@nx/devkit";
+/** One child process: `node <args…>` in `cwd`. */
+export interface Step {
+    /** Shown before the step runs. */
+    label: string;
+    /** Arguments after the Node binary (`[bin, …args]` or `["--input-type=module", "-e", code]`). */
+    args: string[];
+    cwd: string;
+    env?: Record<string, string>;
+}
+/** The project folder (absolute) of the running target. */
+export declare function projectRoot(context: ExecutorContext): string;
+/** The package folder of `pkg` as Node would find it from `from` (walks up `node_modules`); real path. */
+export declare function packageDir(pkg: string, from: string): string;
+/** Absolute path of a package's bin (`bin` field; `name` picks one of several). */
+export declare function binPath(pkg: string, from: string, name?: string): string;
+/** Tool lookup the normalisers use; tests pass a fake one. */
+export type BinResolver = (pkg: string, name?: string) => string;
+export declare const resolverFrom: (from: string) => BinResolver;
+/** Command-line flags from an options object (`--port 4510`, `--open`), in a fixed order. */
+export declare function flags(entries: [flag: string, value: string | number | boolean | undefined][]): string[];
+/** Starts a step; `exit` resolves with its status (signals count as failure). */
+export declare function start(step: Step): {
+    child: ChildProcess;
+    exit: Promise<number>;
+};
+/** Runs steps in order; stops at the first failure. */
+export declare function runSteps(steps: Step[], { verbose }?: {
+    verbose?: boolean | undefined;
+}): Promise<{
+    success: boolean;
+}>;

package/executors/run.js

@@ -0,0 +1,88 @@
+// Shared executor plumbing: resolve a tool's bin from the project folder (the project's own install wins, then the
+// workspace's, like `npm run`), run steps as child processes (`node <bin> …`, so no shell and no PATH lookup), and
+// stream their output. Executors normalise their options into `Step[]` with pure functions (unit-tested).
+import { spawn } from "node:child_process";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+/** The project folder (absolute) of the running target. */
+export function projectRoot(context) {
+    const name = context.projectName;
+    const project = name ? context.projectsConfigurations?.projects[name] : undefined;
+    if (!project)
+        throw new Error(`@rivetjs/nx: no project for ${name ?? "(unknown)"}`);
+    return resolve(context.root, project.root);
+}
+/** The package folder of `pkg` as Node would find it from `from` (walks up `node_modules`); real path. */
+export function packageDir(pkg, from) {
+    for (let dir = resolve(from);; dir = dirname(dir)) {
+        const candidate = join(dir, "node_modules", pkg, "package.json");
+        if (existsSync(candidate))
+            return realpathSync(dirname(candidate));
+        if (dirname(dir) === dir)
+            throw new Error(`@rivetjs/nx: cannot find ${pkg} from ${from} (install it in the workspace)`);
+    }
+}
+/** Absolute path of a package's bin (`bin` field; `name` picks one of several). */
+export function binPath(pkg, from, name) {
+    const dir = packageDir(pkg, from);
+    const manifest = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+    const bin = typeof manifest.bin === "string" ? manifest.bin : manifest.bin?.[name ?? pkg.split("/").pop()];
+    if (!bin)
+        throw new Error(`@rivetjs/nx: ${pkg} has no bin${name ? ` "${name}"` : ""}`);
+    return join(dir, bin);
+}
+export const resolverFrom = (from) => (pkg, name) => binPath(pkg, from, name);
+/** Command-line flags from an options object (`--port 4510`, `--open`), in a fixed order. */
+export function flags(entries) {
+    const out = [];
+    for (const [flag, value] of entries) {
+        if (value === undefined || value === false)
+            continue;
+        out.push(flag);
+        if (value !== true)
+            out.push(String(value));
+    }
+    return out;
+}
+/** Children started by this process (killed when it gets SIGINT / SIGTERM, so continuous targets stop cleanly). */
+const children = new Set();
+let hooked = false;
+function hookSignals() {
+    if (hooked)
+        return;
+    hooked = true;
+    for (const signal of ["SIGINT", "SIGTERM"]) {
+        process.once(signal, () => {
+            for (const child of children)
+                child.kill(signal);
+            process.exit(130);
+        });
+    }
+}
+/** Starts a step; `exit` resolves with its status (signals count as failure). */
+export function start(step) {
+    hookSignals();
+    const child = spawn(process.execPath, step.args, { cwd: step.cwd, env: { ...process.env, ...step.env }, stdio: "inherit" });
+    children.add(child);
+    const exit = new Promise((done) => {
+        child.on("error", (error) => {
+            console.error(error);
+            done(1);
+        });
+        child.on("exit", (code) => {
+            children.delete(child);
+            done(code ?? 1);
+        });
+    });
+    return { child, exit };
+}
+/** Runs steps in order; stops at the first failure. */
+export async function runSteps(steps, { verbose = true } = {}) {
+    for (const step of steps) {
+        if (verbose)
+            console.log(`> ${step.label}`);
+        if ((await start(step).exit) !== 0)
+            return { success: false };
+    }
+    return { success: true };
+}

package/executors/test/executor.d.ts

@@ -0,0 +1,8 @@
+import type { ExecutorContext } from "@nx/devkit";
+import { type BinResolver, type Step } from "../run.js";
+import type { TestExecutorSchema } from "./schema.js";
+export type { TestExecutorSchema } from "./schema.js";
+export declare function testStep(options: TestExecutorSchema, root: string, bin: BinResolver): Step;
+export default function testExecutor(options: TestExecutorSchema, context: ExecutorContext): Promise<{
+    success: boolean;
+}>;

package/executors/test/executor.js

@@ -0,0 +1,27 @@
+import { flags, projectRoot, resolverFrom, runSteps } from "../run.js";
+export function testStep(options, root, bin) {
+    return {
+        label: options.watch ? "vitest (watch)" : "vitest run",
+        args: [
+            bin("vitest"),
+            ...(options.watch ? [] : ["run"]),
+            ...(options.testFiles ?? []),
+            ...flags([
+                ["--config", options.config],
+                ["--coverage", options.coverage],
+                ["--maxWorkers", options.maxWorkers],
+                ["--passWithNoTests", options.passWithNoTests ?? true],
+                ["--update", options.update],
+                ["--testNamePattern", options.testNamePattern],
+            ]),
+            ...(options.project ?? []).flatMap((name) => ["--project", name]),
+            ...(options.reporters ?? []).flatMap((name) => ["--reporter", name]),
+        ],
+        cwd: root,
+        env: options.env ?? {},
+    };
+}
+export default async function testExecutor(options, context) {
+    const root = projectRoot(context);
+    return runSteps([testStep(options, root, resolverFrom(root))]);
+}

package/executors/test/schema.d.ts

@@ -0,0 +1,24 @@
+export interface TestExecutorSchema {
+  /** Vitest config file, relative to the project (default: Vitest's lookup, `vitest.config.ts`). */
+  config?: string;
+  /** Watch mode (`vitest` instead of `vitest run`). Default false. */
+  watch?: boolean;
+  /** Collect coverage (`--coverage`, output `coverage/`). */
+  coverage?: boolean;
+  /** Worker cap (`--maxWorkers`). */
+  maxWorkers?: number | string;
+  /** Succeed when no test file matches. Default true. */
+  passWithNoTests?: boolean;
+  /** Update snapshots (`-u`). */
+  update?: boolean;
+  /** Vitest projects to run (`--project`, e.g. `dom`, `server`). */
+  project?: string[];
+  /** Test file filters (positional). */
+  testFiles?: string[];
+  /** Test name pattern (`-t`). */
+  testNamePattern?: string;
+  /** Vitest reporter(s). */
+  reporters?: string[];
+  /** Extra environment variables. */
+  env?: Record<string, string>;
+}

package/executors/test/schema.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "version": 2,
+  "title": "Rivet test",
+  "description": "Runs Vitest in the project folder (the project's vitest.config.ts with rivetTest() from @rivetjs/testing/vite: DOM target in happy-dom, server target for *.server.test.tsx).",
+  "type": "object",
+  "properties": {
+    "config": { "type": "string", "description": "Vitest config file, relative to the project." },
+    "watch": { "type": "boolean", "default": false, "description": "Watch mode." },
+    "coverage": { "type": "boolean", "description": "Collect coverage (coverage/)." },
+    "maxWorkers": { "oneOf": [{ "type": "number" }, { "type": "string" }], "description": "Worker cap (--maxWorkers)." },
+    "passWithNoTests": { "type": "boolean", "default": true, "description": "Succeed when no test file matches." },
+    "update": { "type": "boolean", "description": "Update snapshots (-u)." },
+    "project": { "type": "array", "items": { "type": "string" }, "description": "Vitest projects to run (--project)." },
+    "testFiles": { "type": "array", "items": { "type": "string" }, "description": "Test file filters." },
+    "testNamePattern": { "type": "string", "description": "Test name pattern (-t)." },
+    "reporters": { "type": "array", "items": { "type": "string" }, "description": "Vitest reporters." },
+    "env": { "type": "object", "additionalProperties": { "type": "string" }, "description": "Extra environment variables." }
+  },
+  "additionalProperties": false
+}

package/executors/typecheck/executor.d.ts

@@ -0,0 +1,9 @@
+import type { ExecutorContext } from "@nx/devkit";
+import type { ProjectFacts } from "../../utils/detect.js";
+import { type BinResolver, type Step } from "../run.js";
+import type { TypecheckExecutorSchema } from "./schema.js";
+export type { TypecheckExecutorSchema } from "./schema.js";
+export declare function typecheckSteps(options: TypecheckExecutorSchema, root: string, facts: ProjectFacts | undefined, bin: BinResolver): Step[];
+export default function typecheckExecutor(options: TypecheckExecutorSchema, context: ExecutorContext): Promise<{
+    success: boolean;
+}>;

package/executors/typecheck/executor.js

@@ -0,0 +1,14 @@
+import { projectFacts } from "../../utils/facts.js";
+import { syncStep } from "../check/executor.js";
+import { projectRoot, resolverFrom, runSteps } from "../run.js";
+export function typecheckSteps(options, root, facts, bin) {
+    const steps = [];
+    if (options.sync ?? facts?.kind === "app")
+        steps.push(syncStep(root, bin));
+    steps.push({ label: "tsc --noEmit", args: [bin("typescript", "tsc"), "-p", options.tsConfig ?? "tsconfig.json", "--noEmit"], cwd: root });
+    return steps;
+}
+export default async function typecheckExecutor(options, context) {
+    const root = projectRoot(context);
+    return runSteps(typecheckSteps(options, root, projectFacts(root), resolverFrom(root)));
+}

package/executors/typecheck/schema.d.ts

@@ -0,0 +1,6 @@
+export interface TypecheckExecutorSchema {
+  /** tsconfig file, relative to the project. Default `tsconfig.json`. */
+  tsConfig?: string;
+  /** Run `rivet sync` first, so `.rivet/routes.d.ts` is current. Default: routed apps only. */
+  sync?: boolean;
+}

package/executors/typecheck/schema.json

@@ -0,0 +1,12 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "version": 2,
+  "title": "Rivet typecheck",
+  "description": "tsc --noEmit for a project; routed apps run rivet sync first so the generated route types (.rivet/routes.d.ts) are current.",
+  "type": "object",
+  "properties": {
+    "tsConfig": { "type": "string", "default": "tsconfig.json", "description": "tsconfig file, relative to the project." },
+    "sync": { "type": "boolean", "description": "Run rivet sync first. Default: routed apps only." }
+  },
+  "additionalProperties": false
+}

package/executors.json

@@ -0,0 +1,49 @@
+{
+  "executors": {
+    "build": {
+      "implementation": "./executors/build/executor",
+      "schema": "./executors/build/schema.json",
+      "description": "Client + server Vite builds (one client build per locale with i18n), then prerender for static apps."
+    },
+    "dev": {
+      "implementation": "./executors/dev/executor",
+      "schema": "./executors/dev/schema.json",
+      "description": "Vite dev server."
+    },
+    "serve": {
+      "implementation": "./executors/dev/executor",
+      "schema": "./executors/dev/schema.json",
+      "description": "Vite dev server (alias of dev)."
+    },
+    "preview": {
+      "implementation": "./executors/preview/executor",
+      "schema": "./executors/preview/schema.json",
+      "description": "Serve the build: the project's serve.js, the router's Node server, or vite preview."
+    },
+    "prerender": {
+      "implementation": "./executors/prerender/executor",
+      "schema": "./executors/prerender/schema.json",
+      "description": "Render every page of an existing build to HTML files (prerenderBuild)."
+    },
+    "check": {
+      "implementation": "./executors/check/executor",
+      "schema": "./executors/check/schema.json",
+      "description": "Rivet diagnostics (rivet sync + rivet-check)."
+    },
+    "test": {
+      "implementation": "./executors/test/executor",
+      "schema": "./executors/test/schema.json",
+      "description": "Vitest with the project's rivetTest() config."
+    },
+    "typecheck": {
+      "implementation": "./executors/typecheck/executor",
+      "schema": "./executors/typecheck/schema.json",
+      "description": "tsc --noEmit (rivet sync first for routed apps)."
+    },
+    "package": {
+      "implementation": "./executors/package/executor",
+      "schema": "./executors/package/schema.json",
+      "description": "Publishable library package: .js / .jsx (JSX preserved) + .d.ts and a mapped package.json."
+    }
+  }
+}

package/generators/api-route/files/__fileName__.ts.template

@@ -0,0 +1,11 @@
+import type { RequestEvent } from "@rivetjs/router";
+<% for (const method of methods) { %>
+/** `<%= method.toUpperCase() %> <%= url %>`. Runs only on the server; must return a `Response`. */
+export const on<%= method[0].toUpperCase() + method.slice(1) %> = async (<% if (method === "get" || method === "delete") { %>{ params }<% } else { %>{ request, params }<% } %>: RequestEvent) => {<% if (method === "get") { %>
+  return Response.json({ ok: true, params }, { headers: { "cache-control": "no-store" } });<% } else if (method === "delete") { %>
+  console.log("delete", params);
+  return new Response(null, { status: 204 });<% } else { %>
+  const body: unknown = await request.json().catch(() => null);
+  return Response.json({ ok: true, params, body }<% if (method === "post") { %>, { status: 201 }<% } %>);<% } %>
+};
+<% } %>

package/generators/api-route/generator.d.ts

@@ -0,0 +1,5 @@
+import { type Tree } from "@nx/devkit";
+import type { ApiRouteGeneratorSchema } from "./schema.js";
+export type { ApiRouteGeneratorSchema } from "./schema.js";
+export declare function apiRouteGenerator(tree: Tree, options: ApiRouteGeneratorSchema): Promise<void>;
+export default apiRouteGenerator;

package/generators/api-route/generator.js

@@ -0,0 +1,30 @@
+// `nx g @rivetjs/nx:api-route api/items/[id] --project=web --methods=get,post`: an endpoint route (plain `.ts`
+// in src/routes exporting request handlers). Server-rendered apps only: a prerendered site has no server.
+import { fileURLToPath } from "node:url";
+import { formatFiles, generateFiles, joinPathFragments } from "@nx/devkit";
+import { routedApp, routeSegments } from "../../utils/project.js";
+import { routeUrl } from "../route/generator.js";
+const FILES = fileURLToPath(new URL("./files", import.meta.url));
+const METHODS = ["get", "post", "put", "patch", "delete"];
+export async function apiRouteGenerator(tree, options) {
+    const project = routedApp(tree, options.project, "api-route");
+    if (project.facts?.static)
+        throw new Error('api-route: endpoints need a server; this app is prerendered (rivetRouter({ mode: "static" }))');
+    const segments = routeSegments(options.path);
+    if (!segments.length)
+        throw new Error("api-route: path is required (e.g. api/health)");
+    const methods = [...new Set((options.methods ?? ["get"]).flatMap((method) => String(method).split(",")).map((method) => method.trim().toLowerCase()))];
+    for (const method of methods)
+        if (!METHODS.includes(method))
+            throw new Error(`api-route: unknown method "${method}"`);
+    const folder = joinPathFragments(project.routes, ...segments.slice(0, -1));
+    const fileName = segments.at(-1);
+    for (const ext of [".ts", ".tsx", ".js", ".jsx"]) {
+        if (tree.exists(joinPathFragments(folder, fileName + ext)))
+            throw new Error(`api-route: ${joinPathFragments(folder, fileName + ext)} already exists`);
+    }
+    generateFiles(tree, FILES, folder, { fileName, methods: METHODS.filter((method) => methods.includes(method)), url: routeUrl(segments) });
+    if (!options.skipFormat)
+        await formatFiles(tree);
+}
+export default apiRouteGenerator;

package/generators/api-route/schema.d.ts

@@ -0,0 +1,9 @@
+export interface ApiRouteGeneratorSchema {
+  /** Endpoint path under `src/routes` (`api/health`, `api/items/[id]`). */
+  path: string;
+  /** The Rivet app. */
+  project: string;
+  /** Request handlers to write. Default `["get"]`. */
+  methods?: ("get" | "post" | "put" | "patch" | "delete")[];
+  skipFormat?: boolean;
+}

package/generators/api-route/schema.json

@@ -0,0 +1,31 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "RivetApiRoute",
+  "title": "Rivet API route",
+  "description": "Adds an endpoint route (a plain .ts file in src/routes with onGet / onPost / … request handlers) to a server-rendered Rivet app.",
+  "type": "object",
+  "properties": {
+    "path": {
+      "type": "string",
+      "description": "Endpoint path under src/routes (api/health, api/items/[id]).",
+      "$default": { "$source": "argv", "index": 0 },
+      "x-prompt": "Endpoint path (under src/routes, e.g. api/health)?"
+    },
+    "project": {
+      "type": "string",
+      "description": "The Rivet app.",
+      "$default": { "$source": "projectName" },
+      "x-dropdown": "projects",
+      "x-prompt": "Which project?"
+    },
+    "methods": {
+      "type": "array",
+      "items": { "type": "string", "enum": ["get", "post", "put", "patch", "delete"] },
+      "default": ["get"],
+      "description": "Request handlers to write."
+    },
+    "skipFormat": { "type": "boolean", "default": false, "x-priority": "internal", "description": "Skip formatting files." }
+  },
+  "required": ["path", "project"],
+  "additionalProperties": false
+}

package/generators/application/files/tests/minimal/src/routes/index.test.tsx.template

@@ -0,0 +1,9 @@
+import { expect, test } from "vitest";
+import { fire, render } from "@rivetjs/runtime/testing";
+import Home from "./index.tsx";
+
+test("counts clicks", () => {
+  const view = render(() => <Home />);
+  fire(view.find("button"), "click");
+  expect(view.find("button").textContent).toBe("Clicked 1 times");
+});

package/generators/application/files/tests/server/src/routes/index.server.test.tsx.template

@@ -0,0 +1,8 @@
+import { expect, test } from "vitest";
+import { renderToString } from "@rivetjs/runtime/testing/server";
+import Home from "./index.tsx";
+
+test("renders the loader's notes on the server", async () => {
+  const html = await renderToString(() => <Home data={{ notes: ["First note"] }} params={{}} url={new URL("http://localhost/")} />);
+  expect(html).toContain("First note");
+});

package/generators/application/files/tests/static/src/components/Counter.test.tsx.template

@@ -0,0 +1,10 @@
+import { expect, test } from "vitest";
+import { fire, render } from "@rivetjs/runtime/testing";
+import { Counter } from "./Counter.tsx";
+
+test("counts clicks", () => {
+  const view = render(() => <Counter />);
+  const button = view.find("button");
+  fire(button, "click");
+  expect(button.textContent).toBe("Clicked 1 times");
+});

package/generators/application/files/tests/ui/src/components/LikeButton.server.test.tsx.template

@@ -0,0 +1,7 @@
+import { expect, test } from "vitest";
+import { renderToString } from "@rivetjs/runtime/testing/server";
+import { LikeButton } from "./LikeButton.tsx";
+
+test("renders the like count on the server", async () => {
+  expect(await renderToString(() => <LikeButton />)).toContain("Liked 0 times");
+});

package/generators/application/files/vitest/vitest.config.ts.template

@@ -0,0 +1,16 @@
+import { defineConfig } from "vitest/config";
+import { rivetTest } from "@rivetjs/testing/vite";
+
+// Two projects: components in happy-dom (DOM target), `*.server.test.tsx` as server HTML in Node.
+export default defineConfig({
+  plugins: [rivetTest()],
+  test: {
+    projects: [
+      {
+        extends: true,
+        test: { name: "dom", include: ["src/**/*.test.tsx"], exclude: ["src/**/*.server.test.tsx"], environment: "happy-dom" },
+      },
+      { extends: true, test: { name: "server", include: ["src/**/*.server.test.tsx"], environment: "node" } },
+    ],
+  },
+});

package/generators/application/generator.d.ts

@@ -0,0 +1,20 @@
+import { type GeneratorCallback, type Tree } from "@nx/devkit";
+import { type DeployTarget } from "../../utils/deploy.js";
+import type { ApplicationGeneratorSchema } from "./schema.js";
+export type { ApplicationGeneratorSchema } from "./schema.js";
+export interface NormalizedApplicationOptions {
+    directory: string;
+    name: string;
+    template: "static" | "server" | "ui" | "minimal";
+    adapter: "node" | "static";
+    /** create-rivet `--deploy` platform target. */
+    deploy?: DeployTarget;
+    tailwind: boolean;
+    unitTestRunner: "vitest" | "none";
+    tags: string[];
+    rivet: string;
+    addPlugin: boolean;
+}
+export declare function normalizeApplicationOptions(tree: Tree, options: ApplicationGeneratorSchema): NormalizedApplicationOptions;
+export declare function applicationGenerator(tree: Tree, schema: ApplicationGeneratorSchema): Promise<GeneratorCallback>;
+export default applicationGenerator;

package/generators/application/generator.js

@@ -0,0 +1,161 @@
+// `nx g @rivetjs/nx:application apps/web --template=static|server|ui|minimal [--adapter=node|static] [--tailwind]`:
+// a create-rivet starter in an Nx workspace. The starter files come from create-rivet (`utils/starter.ts`); this
+// generator only layers Nx concerns over them: project.json, adapter / Tailwind switches, Vitest, dependencies.
+import { fileURLToPath } from "node:url";
+import { addDependenciesToPackageJson, formatFiles, generateFiles, getProjects, joinPathFragments, names, installPackagesTask, readJson, writeJson, } from "@nx/devkit";
+import { applyDeploy, deployProblem, deployScripts, findDeployTarget } from "../../utils/deploy.js";
+import { treeFacts } from "../../utils/facts.js";
+import { starterFile, writeStarter } from "../../utils/starter.js";
+import { rivetTargets } from "../../utils/targets.js";
+import { HAPPY_DOM_VERSION, rivetRange, toolVersion, VITEST_VERSION } from "../../utils/versions.js";
+import { addImport, addPlugin, removePlugin, setRouterOption } from "../../utils/vite-config.js";
+import { addToWorkspaces, isWorkspacePackage, offsetTo, shouldAddPlugin } from "../../utils/workspace.js";
+import { initGenerator } from "../init/generator.js";
+const FILES = fileURLToPath(new URL("./files", import.meta.url));
+export function normalizeApplicationOptions(tree, options) {
+    const directory = options.directory.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+$/, "");
+    if (!directory)
+        throw new Error("application: directory is required (e.g. apps/web)");
+    const name = options.name ?? names(directory.split("/").pop()).fileName;
+    const template = options.template ?? "static";
+    const adapter = options.adapter ?? (template === "server" ? "node" : "static");
+    const tailwind = options.tailwind ?? template !== "minimal";
+    if (template === "ui" && !tailwind)
+        throw new Error("application: the ui starter needs Tailwind (@rivetjs/ui styles are Tailwind v4)");
+    if (template === "server" && adapter === "static")
+        throw new Error("application: the server starter's form action needs a server; use --template=static for a prerendered site");
+    const deploy = options.deploy;
+    if (deploy !== undefined) {
+        if (!findDeployTarget(deploy))
+            throw new Error(`application: unknown deploy target "${deploy}"`);
+        const problem = deployProblem(deploy, template);
+        if (problem)
+            throw new Error(`application: ${problem}`);
+    }
+    if (getProjects(tree).has(name))
+        throw new Error(`application: a project named "${name}" already exists`);
+    if (tree.exists(directory) && tree.children(directory).length)
+        throw new Error(`application: ${directory} is not empty`);
+    return {
+        directory,
+        name,
+        template,
+        adapter,
+        ...(deploy ? { deploy } : {}),
+        tailwind,
+        unitTestRunner: options.unitTestRunner ?? "vitest",
+        tags: (options.tags ?? "")
+            .split(",")
+            .map((tag) => tag.trim())
+            .filter(Boolean),
+        rivet: rivetRange(options.rivetVersion),
+        addPlugin: shouldAddPlugin(tree, options.addPlugin),
+    };
+}
+/** Static ↔ node: router `mode`, the preview / prerender scripts of the matching starter. */
+function applyAdapter(tree, o) {
+    const vite = joinPathFragments(o.directory, "vite.config.ts");
+    const isStatic = o.template !== "server";
+    if ((o.adapter === "static") === isStatic)
+        return;
+    // A static starter served by Node: no prerender step, the server starter's serve.js.
+    tree.write(vite, setRouterOption(tree.read(vite, "utf8"), "mode", undefined).replace(/\/\/ Pages in src\/routes are rendered to HTML files[^\n]*\n/, ""));
+    tree.delete(joinPathFragments(o.directory, "prerender.js"));
+    tree.write(joinPathFragments(o.directory, "serve.js"), starterFile("server", "serve.js"));
+}
+const TAILWIND_IMPORT = 'import tailwindcss from "@tailwindcss/vite";';
+/** Tailwind off for a Tailwind starter, or on for the minimal one. */
+function applyTailwind(tree, o, pkg) {
+    const vite = joinPathFragments(o.directory, "vite.config.ts");
+    const styles = joinPathFragments(o.directory, "src/styles.css");
+    const has = tree.read(vite, "utf8").includes("@tailwindcss/vite");
+    if (o.tailwind === has)
+        return;
+    const dev = (pkg.devDependencies ??= {});
+    if (!o.tailwind) {
+        tree.write(vite, removePlugin(tree.read(vite, "utf8"), "tailwindcss()", /@tailwindcss\/vite/));
+        delete dev["tailwindcss"];
+        delete dev["@tailwindcss/vite"];
+        tree.write(styles, "body {\n  margin: 0;\n  font-family: system-ui, sans-serif;\n}\n");
+        return;
+    }
+    let text = addImport(tree.read(vite, "utf8"), TAILWIND_IMPORT);
+    text = addPlugin(text, "tailwindcss()", "last");
+    text = setRouterOption(text, "styles", '["src/styles.css"]');
+    tree.write(vite, text);
+    tree.write(styles, starterFile("static", "src/styles.css"));
+    dev["tailwindcss"] = toolVersion("tailwindcss");
+    dev["@tailwindcss/vite"] = toolVersion("@tailwindcss/vite");
+}
+/** The README section that maps the starter's npm scripts to Nx targets. */
+function nxReadme(o) {
+    const lines = [
+        "",
+        "## Nx",
+        "",
+        "In this workspace the package.json scripts are Nx targets:",
+        "",
+        `- \`nx dev ${o.name}\`: dev server`,
+        `- \`nx build ${o.name}\`: client + server build${o.adapter === "static" ? ", then every page prerendered to `dist/client`" : ""} (cached)`,
+        `- \`nx preview ${o.name}\`: serve the build`,
+        `- \`nx check ${o.name}\` / \`nx typecheck ${o.name}\`: Rivet diagnostics / TypeScript`,
+    ];
+    if (o.unitTestRunner === "vitest")
+        lines.push(`- \`nx test ${o.name}\`: Vitest`);
+    if (o.deploy && deployScripts(o.deploy)["deploy"])
+        lines.push(`- \`nx deploy ${o.name}\`: build, then deploy (\`${deployScripts(o.deploy)["deploy"]}\`)`);
+    lines.push(`- \`nx g @rivetjs/nx:route <path> --project=${o.name}\`, \`nx g @rivetjs/nx:component <Name> --project=${o.name}\`: new route / component`, "");
+    return lines.join("\n");
+}
+export async function applicationGenerator(tree, schema) {
+    const o = normalizeApplicationOptions(tree, schema);
+    await initGenerator(tree, {
+        addPlugin: o.addPlugin,
+        skipFormat: true,
+        skipInstall: true,
+        ...(schema.rivetVersion ? { rivetVersion: schema.rivetVersion } : {}),
+        ...(schema.skipPackageJson ? { skipPackageJson: true } : {}),
+    });
+    writeStarter(tree, o.template, o.directory, o.name, o.rivet);
+    const pkgPath = joinPathFragments(o.directory, "package.json");
+    let pkg = readJson(tree, pkgPath);
+    // Nx targets replace the npm scripts (inferred from vite.config.ts, or written to project.json below).
+    delete pkg["scripts"];
+    applyAdapter(tree, o);
+    applyTailwind(tree, o, pkg);
+    // After the adapter / Tailwind edits: the overlay edits the final vite.config.ts (as create-rivet does after copying).
+    if (o.deploy)
+        pkg = applyDeploy(tree, o.directory, o.template, o.deploy, o.name, pkg);
+    if (o.unitTestRunner === "vitest") {
+        generateFiles(tree, joinPathFragments(FILES, "vitest"), o.directory, {});
+        generateFiles(tree, joinPathFragments(FILES, "tests", o.template), o.directory, {});
+        const dev = (pkg.devDependencies ??= {});
+        dev["@rivetjs/testing"] = o.rivet;
+        dev["vitest"] = VITEST_VERSION;
+        dev["happy-dom"] = HAPPY_DOM_VERSION;
+    }
+    writeJson(tree, pkgPath, pkg);
+    const readme = joinPathFragments(o.directory, "README.md");
+    if (tree.exists(readme))
+        tree.write(readme, tree.read(readme, "utf8").replace(/\n*$/, "\n") + nxReadme(o));
+    const facts = treeFacts(tree, o.directory);
+    writeJson(tree, joinPathFragments(o.directory, "project.json"), {
+        name: o.name,
+        $schema: `${offsetTo(o.directory)}/node_modules/nx/schemas/project-schema.json`,
+        projectType: "application",
+        sourceRoot: `${o.directory}/src`,
+        tags: o.tags,
+        // Inferred by @rivetjs/nx/plugin; written out when inference is off.
+        targets: o.addPlugin || !facts ? {} : rivetTargets(facts),
+    });
+    // Package-based workspaces install the app's own package.json; others get its dependencies at the root.
+    addToWorkspaces(tree, o.directory);
+    const workspacePackage = isWorkspacePackage(tree, o.directory);
+    if (!schema.skipPackageJson && !workspacePackage)
+        addDependenciesToPackageJson(tree, pkg.dependencies ?? {}, pkg.devDependencies ?? {});
+    if (!schema.skipFormat)
+        await formatFiles(tree);
+    // One install after the files are written (a workspace package changes no root manifest: always run then).
+    return schema.skipInstall ? () => { } : () => installPackagesTask(tree, workspacePackage);
+}
+export default applicationGenerator;