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

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Denys Severyn
+
+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,64 @@
-# Temporary Holding Version
+# @rivetjs/nx
 
-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.
+[Nx](https://nx.dev) plugin for [Rivet](https://github.com/rivetjs/rivet): a workspace preset, generators for apps,
+libraries, routes and components, executors, and inferred `build` / `dev` / `preview` / `test` / `check` /
+`typecheck` targets with Nx caching.
+
+## Install
+
+```sh
+# New workspace with a first Rivet app
+npx create-nx-workspace@latest my-org --preset=@rivetjs/nx --template=static
+
+# Existing workspace: installs the plugin and runs its init generator
+npx nx add @rivetjs/nx
+npx nx g @rivetjs/nx:app apps/web
+```
+
+Node.js 24 or newer, Nx 23.
+
+## Generators
+
+| Generator | Alias | Creates |
+| --- | --- | --- |
+| `application` | `app` | A Rivet app from a create-rivet starter: `--template=static\|server\|ui\|minimal`, `--adapter=node\|static`, `--deploy=vercel\|netlify\|cloudflare\|bun\|deno` (create-rivet's deploy files; `deploy` / `preview` targets), `--tailwind`, `--unitTestRunner=vitest\|none`, `--tags`. |
+| `library` | `lib` | A component library: source exports per subpath (`--subpaths=button,card`, `sideEffects: false`), Vitest, `--publishable` package build, `--importPath`. |
+| `component` | `c` | A resumable component + test: `--kind=basic\|overlay` (render-function children), `--story` (a `/stories/<name>` page), `--directory`, `--export`. |
+| `route` | `r`, `page` | A file route: `blog/[slug]`, `docs/[[lang]]/[...path]`, `(group)/page`; `--loader`, `--action`, `--guard`, `--layout`. |
+| `layout` | | `src/routes/<dir>/_layout.tsx`, `--guard`. |
+| `api-route` | `endpoint` | An endpoint route with `onGet` / `onPost` / … (`--methods=get,post`). |
+| `ui-setup` | | `@rivetjs/ui` + Tailwind v4 + its styles (Rivet theme; other looks = `@rivetjs/ui/theme` presets). |
+| `i18n-setup` | | `@rivetjs/i18n`: `i18n.config.ts`, catalogs, the Vite plugin (`--locales=en,de`, `--prefix`). |
+| `init` | | Plugin in `nx.json`, shared tooling dependencies, `.rivet` in `.gitignore`. |
+| `preset` | | `create-nx-workspace --preset=@rivetjs/nx`. |
+
+All generators write through the Nx tree: `--dry-run` shows the files without writing them.
+
+## Executors
+
+| Executor | Runs |
+| --- | --- |
+| `@rivetjs/nx:build` | `vite build` (per locale with i18n) → `vite build --ssr` → prerender (static apps). |
+| `@rivetjs/nx:dev` / `serve` | `vite` (continuous). |
+| `@rivetjs/nx:preview` | The project's `serve.js`, the router's Node server, or `vite preview` (continuous). |
+| `@rivetjs/nx:prerender` | `prerenderBuild()` over an existing build. |
+| `@rivetjs/nx:check` | `rivet sync` + `rivet-check`. |
+| `@rivetjs/nx:test` | `vitest run` with the project's `rivetTest()` config. |
+| `@rivetjs/nx:typecheck` | `rivet sync` + `tsc --noEmit`. |
+| `@rivetjs/nx:package` | Publishable library: `.js` / `.jsx` (JSX preserved) + `.d.ts`, mapped `package.json`. |
+
+## Inferred targets
+
+```json
+{ "plugins": [{ "plugin": "@rivetjs/nx/plugin", "options": { "buildTargetName": "build" } }] }
+```
+
+Every folder with a `package.json` or `project.json` and a Rivet Vite config (`rivetRouter()` /
+`@rivetjs/compiler/vite`) gets `build`, `dev`, `preview`; a Vitest config with `rivetTest()` adds `test`; a
+`tsconfig.json` adds `check` and `typecheck`. Option names: `buildTargetName`, `devTargetName`, `previewTargetName`,
+`testTargetName`, `checkTargetName`, `typecheckTargetName`, `deployTargetName`. A `rivetRouter({ adapter })` of
+`vercel` / `cloudflare` adds `deploy` (`vercel deploy --prebuilt` / `wrangler deploy`); `cloudflare` / `bun` / `deno`
+make `preview` run `wrangler dev` / Bun / Deno. `build`, `test`, `check`, `typecheck` are cached; `.rivet/`,
+`dist/` and `coverage/` are never inputs; `build` outputs `{projectRoot}/dist`.
+
+Docs: [Nx guide](https://github.com/rivetjs/rivet/blob/main/apps/docs/content/guides/tooling/nx.md).

package/executors/build/executor.d.ts

@@ -0,0 +1,12 @@
+import type { ExecutorContext } from "@nx/devkit";
+import type { ProjectFacts } from "../../utils/detect.js";
+import { type BinResolver, type Step } from "../run.js";
+import type { BuildExecutorSchema } from "./schema.js";
+export type { BuildExecutorSchema } from "./schema.js";
+/** Node code of the default prerender step (projects without their own `prerender.js`). */
+export declare function prerenderCode(dist: string): string;
+/** The build steps for a project (pure: `facts` and `bin` are passed in). */
+export declare function buildSteps(options: BuildExecutorSchema, root: string, facts: ProjectFacts | undefined, bin: BinResolver): Step[];
+export default function buildExecutor(options: BuildExecutorSchema, context: ExecutorContext): Promise<{
+    success: boolean;
+}>;

package/executors/build/executor.js

@@ -0,0 +1,50 @@
+// `@rivetjs/nx:build`: `vite build` (per locale with i18n) → `vite build --ssr` → prerender (static apps). The same
+// steps as the starter templates' `build` script, run from the project folder.
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { projectFacts } from "../../utils/facts.js";
+import { flags, projectRoot, resolverFrom, runSteps } from "../run.js";
+/** Node code of the default prerender step (projects without their own `prerender.js`). */
+export function prerenderCode(dist) {
+    return (`import { prerenderBuild } from "@rivetjs/router/static";\n` +
+        `const report = await prerenderBuild({ dist: ${JSON.stringify(dist)} });\n` +
+        `console.log("Prerendered " + report.pages.length + " page(s) into " + ${JSON.stringify(dist + "/client")});\n`);
+}
+/** The build steps for a project (pure: `facts` and `bin` are passed in). */
+export function buildSteps(options, root, facts, bin) {
+    const vite = bin("vite");
+    const dist = options.outputPath ?? "dist";
+    const common = flags([
+        ["--config", options.config],
+        ["--mode", options.mode],
+        ["--logLevel", options.logLevel],
+    ]);
+    const env = options.env ?? {};
+    const steps = [];
+    const locales = options.locales ?? facts?.locales;
+    if (locales?.length) {
+        for (const locale of locales)
+            steps.push({ label: `vite build (client, ${locale})`, args: [vite, "build", ...common], cwd: root, env: { ...env, RIVET_LOCALE: locale } });
+    }
+    else {
+        steps.push({ label: "vite build (client)", args: [vite, "build", ...common], cwd: root, env });
+    }
+    const ssr = options.ssr ?? (facts ? facts.kind === "app" && !facts.csr : false);
+    if (ssr)
+        steps.push({ label: "vite build --ssr (server)", args: [vite, "build", "--ssr", ...common], cwd: root, env });
+    const prerender = options.prerender ?? Boolean(facts?.static);
+    if (prerender) {
+        if (!ssr)
+            throw new Error("@rivetjs/nx:build: prerender needs the server build (ssr: true)");
+        steps.push(facts?.prerenderScript && dist === "dist"
+            ? { label: "node prerender.js", args: [join(root, "prerender.js")], cwd: root, env }
+            : { label: "prerender", args: ["--input-type=module", "-e", prerenderCode(dist)], cwd: root, env });
+    }
+    return steps;
+}
+export default async function buildExecutor(options, context) {
+    const root = projectRoot(context);
+    if (options.config && !existsSync(join(root, options.config)))
+        throw new Error(`@rivetjs/nx:build: ${options.config} not found in ${root}`);
+    return runSteps(buildSteps(options, root, projectFacts(root), resolverFrom(root)));
+}

package/executors/build/schema.d.ts

@@ -0,0 +1,18 @@
+export interface BuildExecutorSchema {
+  /** Vite config file, relative to the project (default: Vite's lookup). */
+  config?: string;
+  /** Vite mode (`--mode`). */
+  mode?: string;
+  /** Also run the server build (`vite build --ssr`). Default: true, except `rivetRouter({ mode: "csr" })` apps. */
+  ssr?: boolean;
+  /** Prerender every page after the builds. Default: true for `rivetRouter({ mode: "static" })` apps. */
+  prerender?: boolean;
+  /** One client build per locale (`RIVET_LOCALE`), for `@rivetjs/i18n` apps. Inferred from `i18n.config.ts`. */
+  locales?: string[];
+  /** Build output folder, relative to the project (must match the router's `dist`). Default `dist`. */
+  outputPath?: string;
+  /** Vite `--logLevel`. */
+  logLevel?: "info" | "warn" | "error" | "silent";
+  /** Extra environment variables for every step. */
+  env?: Record<string, string>;
+}

package/executors/build/schema.json

@@ -0,0 +1,18 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "version": 2,
+  "title": "Rivet build",
+  "description": "Builds a Rivet app with Vite: the client build (one per locale with @rivetjs/i18n), the server build, then the prerender step for static apps.",
+  "type": "object",
+  "properties": {
+    "config": { "type": "string", "description": "Vite config file, relative to the project (default: Vite's lookup)." },
+    "mode": { "type": "string", "description": "Vite mode (--mode)." },
+    "ssr": { "type": "boolean", "description": "Also run the server build (vite build --ssr). Default: true, except csr-mode apps." },
+    "prerender": { "type": "boolean", "description": "Prerender every page after the builds. Default: true for rivetRouter({ mode: \"static\" }) apps." },
+    "locales": { "type": "array", "items": { "type": "string" }, "description": "One client build per locale (RIVET_LOCALE). Inferred from i18n.config.ts." },
+    "outputPath": { "type": "string", "default": "dist", "description": "Build output folder, relative to the project." },
+    "logLevel": { "type": "string", "enum": ["info", "warn", "error", "silent"], "description": "Vite log level." },
+    "env": { "type": "object", "additionalProperties": { "type": "string" }, "description": "Extra environment variables for every step." }
+  },
+  "additionalProperties": false
+}

package/executors/check/executor.d.ts

@@ -0,0 +1,11 @@
+import type { ExecutorContext } from "@nx/devkit";
+import type { ProjectFacts } from "../../utils/detect.js";
+import { type BinResolver, type Step } from "../run.js";
+import type { CheckExecutorSchema } from "./schema.js";
+export type { CheckExecutorSchema } from "./schema.js";
+/** `rivet sync` for projects with a Vite config (the router / compiler plugin writes `.rivet/`). */
+export declare function syncStep(root: string, bin: BinResolver): Step;
+export declare function checkSteps(options: CheckExecutorSchema, root: string, facts: ProjectFacts | undefined, bin: BinResolver): Step[];
+export default function checkExecutor(options: CheckExecutorSchema, context: ExecutorContext): Promise<{
+    success: boolean;
+}>;

package/executors/check/executor.js

@@ -0,0 +1,31 @@
+import { projectFacts } from "../../utils/facts.js";
+import { flags, projectRoot, resolverFrom, runSteps } from "../run.js";
+/** `rivet sync` for projects with a Vite config (the router / compiler plugin writes `.rivet/`). */
+export function syncStep(root, bin) {
+    return { label: "rivet sync", args: [bin("@rivetjs/router", "rivet"), "sync"], cwd: root };
+}
+export function checkSteps(options, root, facts, bin) {
+    const routed = facts?.kind === "app";
+    const steps = [];
+    if (options.sync ?? routed)
+        steps.push(syncStep(root, bin));
+    const configs = options.tsConfig === undefined ? ["tsconfig.json"] : Array.isArray(options.tsConfig) ? options.tsConfig : [options.tsConfig];
+    steps.push({
+        label: "rivet-check",
+        args: [
+            bin("@rivetjs/language-core", "rivet-check"),
+            ...configs.flatMap((config) => ["-p", config]),
+            ...flags([
+                ["--no-types", options.types === false],
+                ["--no-manifest", !(options.manifest ?? routed)],
+                ["--format", options.format],
+            ]),
+        ],
+        cwd: root,
+    });
+    return steps;
+}
+export default async function checkExecutor(options, context) {
+    const root = projectRoot(context);
+    return runSteps(checkSteps(options, root, projectFacts(root), resolverFrom(root)));
+}

package/executors/check/schema.d.ts

@@ -0,0 +1,12 @@
+export interface CheckExecutorSchema {
+  /** tsconfig file(s) to check, relative to the project. Default `tsconfig.json`. */
+  tsConfig?: string | string[];
+  /** Type-aware checks (RV2101 serializability, RV3101 route links). Default true. */
+  types?: boolean;
+  /** Check `.rivet/editor.json` (RV7101 / RV7102). Default: routed apps only. */
+  manifest?: boolean;
+  /** Run `rivet sync` first (regenerates `.rivet/`). Default: routed apps only. */
+  sync?: boolean;
+  /** Output format. */
+  format?: "text" | "json";
+}

package/executors/check/schema.json

@@ -0,0 +1,18 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "version": 2,
+  "title": "Rivet check",
+  "description": "Rivet diagnostics for a project (rivet-check from @rivetjs/language-core): compiler errors of both targets, serializability, route links. Routed apps run rivet sync first.",
+  "type": "object",
+  "properties": {
+    "tsConfig": {
+      "oneOf": [{ "type": "string" }, { "type": "array", "items": { "type": "string" } }],
+      "description": "tsconfig file(s) to check, relative to the project. Default tsconfig.json."
+    },
+    "types": { "type": "boolean", "default": true, "description": "Type-aware checks (RV2101 serializability, RV3101 route links)." },
+    "manifest": { "type": "boolean", "description": "Check .rivet/editor.json (RV7101 / RV7102). Default: routed apps only." },
+    "sync": { "type": "boolean", "description": "Run rivet sync first. Default: routed apps only." },
+    "format": { "type": "string", "enum": ["text", "json"], "description": "Output format." }
+  },
+  "additionalProperties": false
+}

package/executors/dev/executor.d.ts

@@ -0,0 +1,14 @@
+import type { ExecutorContext } from "@nx/devkit";
+import { type BinResolver, type Step } from "../run.js";
+import type { DevExecutorSchema } from "./schema.js";
+export type { DevExecutorSchema } from "./schema.js";
+export declare function devStep(options: DevExecutorSchema, root: string, bin: BinResolver): Step;
+/** `http://host:port` the server is expected on (Nx shows it; Vite prints the real one). */
+export declare function baseUrl(options: {
+    port?: number;
+    host?: string | boolean;
+}, fallbackPort: number): string;
+export default function devExecutor(options: DevExecutorSchema, context: ExecutorContext): AsyncGenerator<{
+    success: boolean;
+    baseUrl?: string;
+}>;

package/executors/dev/executor.js

@@ -0,0 +1,32 @@
+import { flags, projectRoot, resolverFrom, start } from "../run.js";
+export function devStep(options, root, bin) {
+    return {
+        label: "vite (dev server)",
+        args: [
+            bin("vite"),
+            ...flags([
+                ["--config", options.config],
+                ["--mode", options.mode],
+                ["--port", options.port],
+                ["--host", options.host],
+                ["--strictPort", options.strictPort],
+                ["--open", options.open],
+            ]),
+        ],
+        cwd: root,
+        env: options.env ?? {},
+    };
+}
+/** `http://host:port` the server is expected on (Nx shows it; Vite prints the real one). */
+export function baseUrl(options, fallbackPort) {
+    const host = typeof options.host === "string" ? options.host : "localhost";
+    return `http://${host}:${options.port ?? fallbackPort}`;
+}
+export default async function* devExecutor(options, context) {
+    const root = projectRoot(context);
+    const step = devStep(options, root, resolverFrom(root));
+    console.log(`> ${step.label}`);
+    const { exit } = start(step);
+    yield { success: true, baseUrl: baseUrl(options, 5173) };
+    return { success: (await exit) === 0 };
+}

package/executors/dev/schema.d.ts

@@ -0,0 +1,16 @@
+export interface DevExecutorSchema {
+  /** Port (`--port`); Vite's default 5173. */
+  port?: number;
+  /** Host to listen on (`--host`); `true` = all addresses. */
+  host?: string | boolean;
+  /** Fail when the port is taken instead of trying the next one. */
+  strictPort?: boolean;
+  /** Open the browser. */
+  open?: boolean;
+  /** Vite config file, relative to the project. */
+  config?: string;
+  /** Vite mode. */
+  mode?: string;
+  /** Extra environment variables. */
+  env?: Record<string, string>;
+}

package/executors/dev/schema.json

@@ -0,0 +1,17 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "version": 2,
+  "title": "Rivet dev server",
+  "description": "Runs the Vite dev server of a Rivet app (pages render through the production request handler and resume; hot reload keeps state).",
+  "type": "object",
+  "properties": {
+    "port": { "type": "number", "description": "Port (--port); Vite's default is 5173." },
+    "host": { "oneOf": [{ "type": "string" }, { "type": "boolean" }], "description": "Host to listen on (--host); true listens on all addresses." },
+    "strictPort": { "type": "boolean", "description": "Fail when the port is taken instead of trying the next one." },
+    "open": { "type": "boolean", "description": "Open the browser." },
+    "config": { "type": "string", "description": "Vite config file, relative to the project." },
+    "mode": { "type": "string", "description": "Vite mode." },
+    "env": { "type": "object", "additionalProperties": { "type": "string" }, "description": "Extra environment variables." }
+  },
+  "additionalProperties": false
+}

package/executors/package/executor.d.ts

@@ -0,0 +1,20 @@
+import type { ExecutorContext } from "@nx/devkit";
+import { type BinResolver, type Step } from "../run.js";
+import type { PackageExecutorSchema } from "./schema.js";
+export type { PackageExecutorSchema } from "./schema.js";
+export interface NormalizedPackageOptions {
+    root: string;
+    out: string;
+    tsConfig: string;
+    sourceRoot: string;
+    assets: string[];
+}
+export declare function normalizePackageOptions(options: PackageExecutorSchema, workspaceRoot: string, root: string): NormalizedPackageOptions;
+export declare function emitStep(options: NormalizedPackageOptions, bin: BinResolver): Step;
+/** `./src/button/index.ts` → `./button/index.js` (types: `.d.ts`); `.tsx` → `.jsx`. */
+export declare function mapPath(path: string, sourceRoot: string, types: boolean): string;
+/** The published manifest of a library manifest. */
+export declare function distManifest(pkg: Record<string, unknown>, sourceRoot: string): Record<string, unknown>;
+export default function packageExecutor(options: PackageExecutorSchema, context: ExecutorContext): Promise<{
+    success: boolean;
+}>;

package/executors/package/executor.js

@@ -0,0 +1,65 @@
+// `@rivetjs/nx:package`: publishable Rivet library. `tsc -p tsconfig.lib.json` emits `.js` / `.jsx` (JSX preserved:
+// the consuming app's Rivet compiler compiles it, like every `@rivetjs/*` package) and `.d.ts`; the manifest's
+// source `exports` (`./src/x.ts`) are mapped to the emitted files and workspace-only fields dropped.
+import { cpSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join, relative, resolve } from "node:path";
+import { projectRoot, resolverFrom, runSteps } from "../run.js";
+export function normalizePackageOptions(options, workspaceRoot, root) {
+    return {
+        root,
+        out: resolve(workspaceRoot, options.outputPath ?? join("dist", relative(workspaceRoot, root))),
+        tsConfig: options.tsConfig ?? "tsconfig.lib.json",
+        sourceRoot: (options.sourceRoot ?? "src").replace(/^\.\//, "").replace(/\/$/, ""),
+        assets: options.assets ?? [],
+    };
+}
+export function emitStep(options, bin) {
+    return { label: `tsc -p ${options.tsConfig}`, args: [bin("typescript", "tsc"), "-p", options.tsConfig, "--outDir", options.out], cwd: options.root };
+}
+/** `./src/button/index.ts` → `./button/index.js` (types: `.d.ts`); `.tsx` → `.jsx`. */
+export function mapPath(path, sourceRoot, types) {
+    const prefix = `./${sourceRoot}/`;
+    const inside = path.startsWith(prefix) ? "./" + path.slice(prefix.length) : path;
+    if (/\.d\.[cm]?ts$/.test(inside) || !/\.[cm]?tsx?$/.test(inside))
+        return inside;
+    if (types)
+        return inside.replace(/\.([cm]?)tsx?$/, ".d.$1ts");
+    return inside.replace(/\.([cm]?)ts$/, ".$1js").replace(/\.tsx$/, ".jsx");
+}
+function mapExports(value, sourceRoot, condition = "default") {
+    if (typeof value === "string")
+        return mapPath(value, sourceRoot, condition === "types");
+    if (!value)
+        return value;
+    return Object.fromEntries(Object.entries(value).map(([key, inner]) => [key, mapExports(inner, sourceRoot, key.startsWith(".") ? "default" : key)]));
+}
+/** The published manifest of a library manifest. */
+export function distManifest(pkg, sourceRoot) {
+    const { private: _private, scripts: _scripts, devDependencies: _dev, nx: _nx, ...rest } = pkg;
+    const out = { ...rest };
+    if (pkg["exports"])
+        out["exports"] = mapExports(pkg["exports"], sourceRoot);
+    for (const field of ["main", "module"])
+        if (typeof pkg[field] === "string")
+            out[field] = mapPath(pkg[field], sourceRoot, false);
+    if (typeof pkg["types"] === "string")
+        out["types"] = mapPath(pkg["types"], sourceRoot, true);
+    return out;
+}
+export default async function packageExecutor(options, context) {
+    const root = projectRoot(context);
+    const normalized = normalizePackageOptions(options, context.root, root);
+    rmSync(normalized.out, { recursive: true, force: true });
+    mkdirSync(normalized.out, { recursive: true });
+    const emitted = await runSteps([emitStep(normalized, resolverFrom(root))]);
+    if (!emitted.success)
+        return emitted;
+    const pkg = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+    writeFileSync(join(normalized.out, "package.json"), JSON.stringify(distManifest(pkg, normalized.sourceRoot), null, 2) + "\n");
+    for (const asset of ["README.md", "LICENSE", ...normalized.assets]) {
+        if (existsSync(join(root, asset)))
+            cpSync(join(root, asset), join(normalized.out, asset), { recursive: true });
+    }
+    console.log(`Packaged ${String(pkg["name"])} → ${relative(context.root, normalized.out)}`);
+    return { success: true };
+}

package/executors/package/schema.d.ts

@@ -0,0 +1,10 @@
+export interface PackageExecutorSchema {
+  /** tsconfig of the emit, relative to the project. Default `tsconfig.lib.json`. */
+  tsConfig?: string;
+  /** Output folder, relative to the workspace root. Default `dist/<projectRoot>`. */
+  outputPath?: string;
+  /** Source folder the emit is rooted at (= the tsconfig's `rootDir`), relative to the project. Default `src`. */
+  sourceRoot?: string;
+  /** Extra files copied from the project (README.md and LICENSE are copied when present). */
+  assets?: string[];
+}

package/executors/package/schema.json

@@ -0,0 +1,18 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "version": 2,
+  "title": "Rivet library package",
+  "description": "Builds a publishable Rivet library: tsc emits .js / .jsx (JSX preserved for the consuming app's Rivet compiler) + .d.ts, then a package.json whose exports point at the emitted files.",
+  "type": "object",
+  "properties": {
+    "tsConfig": { "type": "string", "default": "tsconfig.lib.json", "description": "tsconfig of the emit, relative to the project." },
+    "outputPath": { "type": "string", "description": "Output folder, relative to the workspace root. Default dist/<projectRoot>." },
+    "sourceRoot": {
+      "type": "string",
+      "default": "src",
+      "description": "Source folder the emit is rooted at (the tsconfig's rootDir), relative to the project."
+    },
+    "assets": { "type": "array", "items": { "type": "string" }, "description": "Extra files copied from the project." }
+  },
+  "additionalProperties": false
+}

package/executors/prerender/executor.d.ts

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

package/executors/prerender/executor.js

@@ -0,0 +1,13 @@
+// `@rivetjs/nx:prerender`: `prerenderBuild()` over an existing build (pipelines that split build and prerender;
+// the `build` executor already prerenders static apps).
+import { join } from "node:path";
+import { prerenderCode } from "../build/executor.js";
+import { projectRoot, runSteps } from "../run.js";
+export function prerenderStep(options, root) {
+    if (options.script)
+        return { label: `node ${options.script}`, args: [join(root, options.script)], cwd: root };
+    return { label: "prerender", args: ["--input-type=module", "-e", prerenderCode(options.outputPath ?? "dist")], cwd: root };
+}
+export default async function prerenderExecutor(options, context) {
+    return runSteps([prerenderStep(options, projectRoot(context))]);
+}

package/executors/prerender/schema.d.ts

@@ -0,0 +1,6 @@
+export interface PrerenderExecutorSchema {
+  /** Build output folder, relative to the project (holds `client/` + `server/`). Default `dist`. */
+  outputPath?: string;
+  /** Run the project's own script instead (relative to the project, e.g. `prerender.js`). */
+  script?: string;
+}

package/executors/prerender/schema.json

@@ -0,0 +1,12 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "version": 2,
+  "title": "Rivet prerender",
+  "description": "Renders every page of a built Rivet app to HTML files in <outputPath>/client (prerenderBuild of @rivetjs/router/static). Run after the client + server builds.",
+  "type": "object",
+  "properties": {
+    "outputPath": { "type": "string", "default": "dist", "description": "Build output folder, relative to the project (holds client/ and server/)." },
+    "script": { "type": "string", "description": "Run the project's own script instead (relative to the project, e.g. prerender.js)." }
+  },
+  "additionalProperties": false
+}

package/executors/preview/executor.d.ts

@@ -0,0 +1,12 @@
+import type { ExecutorContext } from "@nx/devkit";
+import type { ProjectFacts } from "../../utils/detect.js";
+import { type BinResolver, type Step } from "../run.js";
+import type { PreviewExecutorSchema } from "./schema.js";
+export type { PreviewExecutorSchema } from "./schema.js";
+/** Node code of the router's production server over `dist`. */
+export declare function startCode(dist: string): string;
+export declare function previewStep(options: PreviewExecutorSchema, root: string, facts: ProjectFacts | undefined, bin: BinResolver, serverBuilt: boolean): Step;
+export default function previewExecutor(options: PreviewExecutorSchema, context: ExecutorContext): AsyncGenerator<{
+    success: boolean;
+    baseUrl?: string;
+}>;

package/executors/preview/executor.js

@@ -0,0 +1,52 @@
+// `@rivetjs/nx:preview`: serves the build (continuous target, depends on `build`). The project's own `serve.js`
+// wins (starters ship one); a routed app without it runs `start()` of `@rivetjs/router/node`; anything else
+// gets `vite preview`.
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { projectFacts } from "../../utils/facts.js";
+import { baseUrl } from "../dev/executor.js";
+import { flags, projectRoot, resolverFrom, start } from "../run.js";
+/** Node code of the router's production server over `dist`. */
+export function startCode(dist) {
+    return (`import { closeOnSignals, start } from "@rivetjs/router/node";\n` +
+        `const serving = await start({ dist: ${JSON.stringify(dist)}, port: Number(process.env.PORT ?? 3000), host: process.env.HOST ?? "127.0.0.1" });\n` +
+        `closeOnSignals(serving);\n` +
+        `console.log("Listening on " + serving.url);\n`);
+}
+export function previewStep(options, root, facts, bin, serverBuilt) {
+    const dist = options.outputPath ?? "dist";
+    const env = { ...options.env };
+    if (options.port !== undefined)
+        env["PORT"] = String(options.port);
+    if (options.host !== undefined)
+        env["HOST"] = options.host;
+    if (facts?.serveScript && dist === "dist")
+        return { label: "node serve.js", args: [join(root, "serve.js")], cwd: root, env };
+    if (facts?.kind === "app" && serverBuilt)
+        return { label: "router node server", args: ["--input-type=module", "-e", startCode(dist)], cwd: root, env };
+    return {
+        label: "vite preview",
+        args: [
+            bin("vite"),
+            "preview",
+            ...flags([
+                ["--port", options.port],
+                ["--host", options.host],
+                ["--outDir", facts?.kind === "app" ? `${dist}/client` : undefined],
+            ]),
+        ],
+        cwd: root,
+        env: options.env ?? {},
+    };
+}
+export default async function* previewExecutor(options, context) {
+    const root = projectRoot(context);
+    const dist = options.outputPath ?? "dist";
+    const facts = projectFacts(root);
+    const step = previewStep(options, root, facts, resolverFrom(root), existsSync(join(root, dist, "server")));
+    console.log(`> ${step.label}`);
+    const { exit } = start(step);
+    // Starter defaults: static serve.js and vite preview 4173, server serve.js and the router server 3000.
+    yield { success: true, baseUrl: baseUrl(options, step.label === "vite preview" || facts?.static ? 4173 : 3000) };
+    return { success: (await exit) === 0 };
+}

package/executors/preview/schema.d.ts

@@ -0,0 +1,10 @@
+export interface PreviewExecutorSchema {
+  /** Port (`PORT` for the project's `serve.js` / the router's Node server, `--port` for `vite preview`). */
+  port?: number;
+  /** Host (`HOST` / `--host`). */
+  host?: string;
+  /** Build output folder, relative to the project. Default `dist`. */
+  outputPath?: string;
+  /** Extra environment variables. */
+  env?: Record<string, string>;
+}

package/executors/preview/schema.json

@@ -0,0 +1,14 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "version": 2,
+  "title": "Rivet preview",
+  "description": "Serves a built Rivet app: the project's serve.js when it has one, else the router's Node server (@rivetjs/router/node start), else vite preview.",
+  "type": "object",
+  "properties": {
+    "port": { "type": "number", "description": "Port (PORT for serve.js / the Node server, --port for vite preview)." },
+    "host": { "type": "string", "description": "Host (HOST / --host)." },
+    "outputPath": { "type": "string", "default": "dist", "description": "Build output folder, relative to the project." },
+    "env": { "type": "object", "additionalProperties": { "type": "string" }, "description": "Extra environment variables." }
+  },
+  "additionalProperties": false
+}