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

package/generators/ui-setup/schema.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "RivetUiSetup",
+  "title": "Set up @rivetjs/ui",
+  "description": "Adds @rivetjs/ui to a Rivet app: Tailwind v4 in the Vite config, the ui styles in src/styles.css, and the dependencies (ui, kit, lucide).",
+  "type": "object",
+  "properties": {
+    "project": {
+      "type": "string",
+      "description": "The Rivet app.",
+      "$default": { "$source": "argv", "index": 0 },
+      "x-dropdown": "projects",
+      "x-prompt": "Which project?"
+    },
+    "rivetVersion": { "type": "string", "description": "@rivetjs/* dependency spec (default: this plugin's version)." },
+    "skipPackageJson": { "type": "boolean", "default": false, "x-priority": "internal", "description": "Do not change package.json files." },
+    "skipFormat": { "type": "boolean", "default": false, "x-priority": "internal", "description": "Skip formatting files." }
+  },
+  "required": ["project"],
+  "additionalProperties": false
+}

package/generators.json

@@ -0,0 +1,66 @@
+{
+  "name": "@rivetjs/nx",
+  "version": "0.1",
+  "generators": {
+    "preset": {
+      "factory": "./generators/preset/generator",
+      "schema": "./generators/preset/schema.json",
+      "description": "Workspace preset: npx create-nx-workspace --preset=@rivetjs/nx (init + a first Rivet app).",
+      "x-use-standalone-layout": false,
+      "hidden": true
+    },
+    "init": {
+      "factory": "./generators/init/generator",
+      "schema": "./generators/init/schema.json",
+      "description": "Add @rivetjs/nx to a workspace: Rivet tooling dependencies, the inference plugin in nx.json.",
+      "hidden": true
+    },
+    "application": {
+      "factory": "./generators/application/generator",
+      "schema": "./generators/application/schema.json",
+      "aliases": ["app"],
+      "x-type": "application",
+      "description": "Create a Rivet app from a create-rivet starter (static, server, ui, minimal)."
+    },
+    "library": {
+      "factory": "./generators/library/generator",
+      "schema": "./generators/library/schema.json",
+      "aliases": ["lib"],
+      "x-type": "library",
+      "description": "Create a Rivet component library (tree-shakeable subpath exports, Vitest, optional package build)."
+    },
+    "component": {
+      "factory": "./generators/component/generator",
+      "schema": "./generators/component/schema.json",
+      "aliases": ["c"],
+      "description": "Add a resumable component (+ test, optional story route)."
+    },
+    "route": {
+      "factory": "./generators/route/generator",
+      "schema": "./generators/route/schema.json",
+      "aliases": ["r", "page"],
+      "description": "Add a file route: dynamic segments, serverLoad, serverActions, serverGuard, folder layout."
+    },
+    "layout": {
+      "factory": "./generators/layout/generator",
+      "schema": "./generators/layout/schema.json",
+      "description": "Add a _layout.tsx to a routes folder (optional serverGuard)."
+    },
+    "api-route": {
+      "factory": "./generators/api-route/generator",
+      "schema": "./generators/api-route/schema.json",
+      "aliases": ["endpoint"],
+      "description": "Add an endpoint route (onGet / onPost / … request handlers)."
+    },
+    "ui-setup": {
+      "factory": "./generators/ui-setup/generator",
+      "schema": "./generators/ui-setup/schema.json",
+      "description": "Add @rivetjs/ui + Tailwind v4 + its styles to an app."
+    },
+    "i18n-setup": {
+      "factory": "./generators/i18n-setup/generator",
+      "schema": "./generators/i18n-setup/schema.json",
+      "description": "Add compile-time i18n (@rivetjs/i18n): config, catalogs, Vite plugin."
+    }
+  }
+}

package/index.d.ts

@@ -0,0 +1,22 @@
+export { createNodes, createNodesV2, createRivetProject, CONFIG_GLOB, type RivetPluginOptions } from "./plugin.js";
+export { rivetTargets, targetNames, DEFAULT_TARGET_NAMES } from "./utils/targets.js";
+export { detectProject, routerMode, i18nLocales, type ProjectFacts } from "./utils/detect.js";
+export { initGenerator, type InitGeneratorSchema } from "./generators/init/generator.js";
+export { presetGenerator, type PresetGeneratorSchema } from "./generators/preset/generator.js";
+export { applicationGenerator, normalizeApplicationOptions, type ApplicationGeneratorSchema } from "./generators/application/generator.js";
+export { libraryGenerator, libraryExports, type LibraryGeneratorSchema } from "./generators/library/generator.js";
+export { componentGenerator, type ComponentGeneratorSchema } from "./generators/component/generator.js";
+export { routeGenerator, type RouteGeneratorSchema } from "./generators/route/generator.js";
+export { layoutGenerator, type LayoutGeneratorSchema } from "./generators/layout/generator.js";
+export { apiRouteGenerator, type ApiRouteGeneratorSchema } from "./generators/api-route/generator.js";
+export { uiSetupGenerator, type UiSetupGeneratorSchema } from "./generators/ui-setup/generator.js";
+export { i18nSetupGenerator, type I18nSetupGeneratorSchema } from "./generators/i18n-setup/generator.js";
+export { default as buildExecutor, buildSteps, type BuildExecutorSchema } from "./executors/build/executor.js";
+export { default as devExecutor, devStep, type DevExecutorSchema } from "./executors/dev/executor.js";
+export { default as previewExecutor, previewStep, type PreviewExecutorSchema } from "./executors/preview/executor.js";
+export { default as prerenderExecutor, prerenderStep, type PrerenderExecutorSchema } from "./executors/prerender/executor.js";
+export { default as checkExecutor, checkSteps, type CheckExecutorSchema } from "./executors/check/executor.js";
+export { default as testExecutor, testStep, type TestExecutorSchema } from "./executors/test/executor.js";
+export { default as typecheckExecutor, typecheckSteps, type TypecheckExecutorSchema } from "./executors/typecheck/executor.js";
+export { default as packageExecutor, distManifest, type PackageExecutorSchema } from "./executors/package/executor.js";
+export { default as exampleNoopMigration } from "./migrations/0.0.1/example-noop.js";

package/index.js

@@ -0,0 +1,24 @@
+// @rivetjs/nx: Nx plugin for Rivet. Generators (generators.json), executors (executors.json), inferred tasks
+// (`@rivetjs/nx/plugin`), migrations (migrations.json). Dev tooling only: no Rivet runtime entry imports it.
+export { createNodes, createNodesV2, createRivetProject, CONFIG_GLOB } from "./plugin.js";
+export { rivetTargets, targetNames, DEFAULT_TARGET_NAMES } from "./utils/targets.js";
+export { detectProject, routerMode, i18nLocales } from "./utils/detect.js";
+export { initGenerator } from "./generators/init/generator.js";
+export { presetGenerator } from "./generators/preset/generator.js";
+export { applicationGenerator, normalizeApplicationOptions } from "./generators/application/generator.js";
+export { libraryGenerator, libraryExports } from "./generators/library/generator.js";
+export { componentGenerator } from "./generators/component/generator.js";
+export { routeGenerator } from "./generators/route/generator.js";
+export { layoutGenerator } from "./generators/layout/generator.js";
+export { apiRouteGenerator } from "./generators/api-route/generator.js";
+export { uiSetupGenerator } from "./generators/ui-setup/generator.js";
+export { i18nSetupGenerator } from "./generators/i18n-setup/generator.js";
+export { default as buildExecutor, buildSteps } from "./executors/build/executor.js";
+export { default as devExecutor, devStep } from "./executors/dev/executor.js";
+export { default as previewExecutor, previewStep } from "./executors/preview/executor.js";
+export { default as prerenderExecutor, prerenderStep } from "./executors/prerender/executor.js";
+export { default as checkExecutor, checkSteps } from "./executors/check/executor.js";
+export { default as testExecutor, testStep } from "./executors/test/executor.js";
+export { default as typecheckExecutor, typecheckSteps } from "./executors/typecheck/executor.js";
+export { default as packageExecutor, distManifest } from "./executors/package/executor.js";
+export { default as exampleNoopMigration } from "./migrations/0.0.1/example-noop.js";

package/migrations/0.0.1/example-noop.d.ts

@@ -0,0 +1,2 @@
+import type { Tree } from "@nx/devkit";
+export default function exampleNoopMigration(_tree: Tree): Promise<void>;

package/migrations/0.0.1/example-noop.js

@@ -0,0 +1,3 @@
+export default async function exampleNoopMigration(_tree) {
+    // A real migration edits files here, e.g. `visitNotIgnoredFiles(tree, ".", (path) => …)` + `formatFiles(tree)`.
+}

package/migrations.json

@@ -0,0 +1,10 @@
+{
+  "generators": {
+    "example-noop": {
+      "version": "0.0.1",
+      "description": "Example migration that changes nothing (the path future breaking releases follow).",
+      "implementation": "./migrations/0.0.1/example-noop"
+    }
+  },
+  "packageJsonUpdates": {}
+}

package/package.json

@@ -1,6 +1,76 @@
 {
   "name": "@rivetjs/nx",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0-alpha.0",
+  "license": "MIT",
+  "type": "module",
+  "description": "Nx plugin for Rivet: generators, executors and inferred tasks for Rivet apps and libraries.",
+  "keywords": [
+    "rivet",
+    "nx",
+    "nx-plugin",
+    "generators",
+    "executors",
+    "vite",
+    "jsx",
+    "ssr",
+    "resumable"
+  ],
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    },
+    "./plugin": {
+      "types": "./plugin.d.ts",
+      "default": "./plugin.js"
+    },
+    "./package.json": "./package.json",
+    "./generators.json": "./generators.json",
+    "./executors.json": "./executors.json",
+    "./migrations.json": "./migrations.json",
+    "./generators/*/schema.json": "./generators/*/schema.json",
+    "./executors/*/schema.json": "./executors/*/schema.json"
+  },
+  "generators": "./generators.json",
+  "executors": "./executors.json",
+  "nx-migrations": {
+    "migrations": "./migrations.json"
+  },
+  "dependencies": {
+    "@nx/devkit": "23.2.1",
+    "create-rivet": "0.1.0-alpha.0"
+  },
+  "peerDependencies": {
+    "nx": ">=23 <24"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/N1XUS/rivetjs.git",
+    "directory": "libs/nx"
+  },
+  "homepage": "https://github.com/N1XUS/rivetjs/tree/main/libs/nx#readme",
+  "bugs": {
+    "url": "https://github.com/N1XUS/rivetjs/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "LICENSE",
+    "README.md",
+    "executors",
+    "executors.json",
+    "generators",
+    "generators.json",
+    "index.d.ts",
+    "index.js",
+    "migrations",
+    "migrations.json",
+    "plugin.d.ts",
+    "plugin.js",
+    "utils"
+  ]
+}

package/plugin.d.ts

@@ -0,0 +1,12 @@
+import { type CreateNodes, type CreateNodesContext, type CreateNodesResult } from "@nx/devkit";
+import { type RivetPluginOptions } from "./utils/targets.js";
+export type { RivetPluginOptions } from "./utils/targets.js";
+/** Vite and Vitest config files (one project per folder; a vitest config defers to a sibling vite config). */
+export declare const CONFIG_GLOB = "**/{vite,vitest}.config.{ts,mts,js,mjs}";
+/** The inferred project of one config file (`file` workspace-relative); `{}` when it is not a Rivet project. */
+export declare function createRivetProject(file: string, options: RivetPluginOptions | undefined, context: CreateNodesContext): CreateNodesResult;
+/** Nx 23 plugin API (`createNodes` with the v2 signature). */
+export declare const createNodes: CreateNodes<RivetPluginOptions>;
+/** Same as {@link createNodes}: the name older Nx releases (20–22) look for. */
+export declare const createNodesV2: CreateNodes<RivetPluginOptions>;
+export declare const name = "@rivetjs/nx";

package/plugin.js

@@ -0,0 +1,44 @@
+// Inferred tasks (Nx project crystal): `{ "plugins": [{ "plugin": "@rivetjs/nx/plugin", "options": { … } }] }` in nx.json.
+// Every folder with a Rivet Vite config (`rivetRouter()` / `@rivetjs/compiler/vite`) or a Rivet Vitest config
+// (`rivetTest()`) next to a package.json / project.json becomes a project with build / dev / preview / test / check /
+// typecheck targets (`utils/targets.ts`). Configs are read as text, never executed.
+import { existsSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { createNodesFromFiles } from "@nx/devkit";
+import { VITE_CONFIGS } from "./utils/detect.js";
+import { projectFacts } from "./utils/facts.js";
+import { rivetTargets } from "./utils/targets.js";
+/** Vite and Vitest config files (one project per folder; a vitest config defers to a sibling vite config). */
+export const CONFIG_GLOB = "**/{vite,vitest}.config.{ts,mts,js,mjs}";
+/** The inferred project of one config file (`file` workspace-relative); `{}` when it is not a Rivet project. */
+export function createRivetProject(file, options, context) {
+    const root = dirname(file);
+    const abs = join(context.workspaceRoot, root);
+    if (!existsSync(join(abs, "package.json")) && !existsSync(join(abs, "project.json")))
+        return {};
+    // One result per folder: a vitest config with a sibling vite config is read through the vite config's result.
+    if (basename(file).startsWith("vitest.") && VITE_CONFIGS.some((name) => existsSync(join(abs, name))))
+        return {};
+    const facts = projectFacts(abs);
+    if (!facts)
+        return {};
+    const production = Boolean(context.nxJsonConfiguration.namedInputs?.["production"]);
+    return {
+        projects: {
+            [root]: {
+                root,
+                ...(facts.kind === "lib" ? {} : { projectType: "application" }),
+                targets: rivetTargets(facts, options, { production }),
+                metadata: { technologies: ["rivet"] },
+            },
+        },
+    };
+}
+/** Nx 23 plugin API (`createNodes` with the v2 signature). */
+export const createNodes = [
+    CONFIG_GLOB,
+    (files, options, context) => createNodesFromFiles((file, opts, ctx) => createRivetProject(file, opts, ctx), files, options ?? {}, context),
+];
+/** Same as {@link createNodes}: the name older Nx releases (20–22) look for. */
+export const createNodesV2 = createNodes;
+export const name = "@rivetjs/nx";

package/utils/deploy.d.ts

@@ -0,0 +1,14 @@
+import type { Tree } from "@nx/devkit";
+import type { PackageJson, TemplateId } from "create-rivet";
+import { DEPLOY_TARGETS, deployProblem, findDeployTarget, type DeployTarget } from "create-rivet/deploy";
+export { DEPLOY_TARGETS, deployProblem, findDeployTarget, type DeployTarget };
+/** The npm scripts create-rivet's overlay adds for `adapter` (`deploy`, `preview`, `start`); `{}` for other adapters. */
+export declare function deployScripts(adapter: string | undefined): Record<string, string>;
+/** Folders the router's platform packaging writes outside `dist/` (`libs/router/adapters/pack.ts`): build outputs. */
+export declare function deployOutputs(adapter: string | undefined): string[];
+/**
+ * Applies create-rivet's deploy overlay for `target` to the project at `root`: `edit` runs on a scratch copy of the
+ * project (the overlay edits files on disk), then the files it wrote or removed are mirrored into the tree. `pkg`
+ * gets the overlay's dependencies (scripts are dropped: Nx targets). Throws create-rivet's `deployProblem`.
+ */
+export declare function applyDeploy(tree: Tree, root: string, template: TemplateId, target: DeployTarget, project: string, pkg: PackageJson): PackageJson;

package/utils/deploy.js

@@ -0,0 +1,86 @@
+// `--deploy <target>` in an Nx workspace: create-rivet's own deploy overlay (`create-rivet/deploy`), so a Nx app and
+// `npm create rivet -- --deploy <target>` get the same vite.config adapter, .gitignore lines, netlify.toml, README
+// section, removed files and dependencies. Only the npm scripts the overlay adds become Nx targets instead
+// (`deployScripts` → `utils/targets.ts`), and the README / netlify.toml commands name those targets.
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { DEPLOY_TARGETS, deployOverlay, deployProblem, findDeployTarget } from "create-rivet/deploy";
+export { DEPLOY_TARGETS, deployProblem, findDeployTarget };
+/** The npm scripts create-rivet's overlay adds for `adapter` (`deploy`, `preview`, `start`); `{}` for other adapters. */
+export function deployScripts(adapter) {
+    const target = adapter ? findDeployTarget(adapter) : undefined;
+    if (!target)
+        return {};
+    const pkg = deployOverlay(target.id).manifest?.({}) ?? {};
+    return pkg["scripts"] ?? {};
+}
+/** Folders the router's platform packaging writes outside `dist/` (`libs/router/adapters/pack.ts`): build outputs. */
+export function deployOutputs(adapter) {
+    if (adapter === "vercel" || adapter === "vercel-edge")
+        return ["{projectRoot}/.vercel/output"];
+    if (adapter === "netlify")
+        return ["{projectRoot}/.netlify/v1"];
+    if (adapter === "cloudflare")
+        return ["{projectRoot}/.wrangler/deploy"];
+    return [];
+}
+/** Every file under `root` in the tree (workspace-relative paths). */
+function treeFiles(tree, root) {
+    const out = [];
+    const walk = (dir) => {
+        for (const name of tree.children(dir)) {
+            const path = join(dir, name);
+            if (tree.isFile(path))
+                out.push(path);
+            else
+                walk(path);
+        }
+    };
+    walk(root);
+    return out;
+}
+/** npm script → the Nx target that replaces it (bun / deno `start` = the `preview` target). */
+const TARGET_OF = { build: "build", deploy: "deploy", preview: "preview", start: "preview" };
+/**
+ * Applies create-rivet's deploy overlay for `target` to the project at `root`: `edit` runs on a scratch copy of the
+ * project (the overlay edits files on disk), then the files it wrote or removed are mirrored into the tree. `pkg`
+ * gets the overlay's dependencies (scripts are dropped: Nx targets). Throws create-rivet's `deployProblem`.
+ */
+export function applyDeploy(tree, root, template, target, project, pkg) {
+    const problem = deployProblem(target, template);
+    if (problem)
+        throw new Error(`application: ${problem}`);
+    const overlay = deployOverlay(target, "npm");
+    const next = overlay.manifest ? overlay.manifest(pkg) : pkg;
+    delete next["scripts"];
+    const scratch = mkdtempSync(join(tmpdir(), "rivet-nx-deploy-"));
+    try {
+        for (const file of treeFiles(tree, root)) {
+            const at = join(scratch, file.slice(root.length + 1));
+            mkdirSync(dirname(at), { recursive: true });
+            writeFileSync(at, tree.read(file));
+        }
+        const result = overlay.edit?.(scratch);
+        for (const file of result?.written ?? [])
+            tree.write(join(root, file), readFileSync(join(scratch, file)));
+        for (const file of result?.removed ?? [])
+            tree.delete(join(root, file));
+    }
+    finally {
+        rmSync(scratch, { recursive: true, force: true });
+    }
+    // The overlay's commands run npm scripts; in Nx they are targets.
+    const nx = (text) => text.replace(/\bnpm run (\w+)/g, (all, script) => (TARGET_OF[script] ? `nx ${TARGET_OF[script]} ${project}` : all));
+    const netlify = join(root, "netlify.toml");
+    if (tree.exists(netlify))
+        tree.write(netlify, tree.read(netlify, "utf8").replace(/command = "npm run build"/, `command = "npx nx build ${project}"`));
+    const readme = join(root, "README.md");
+    if (tree.exists(readme)) {
+        const text = tree.read(readme, "utf8");
+        const at = text.indexOf("\n## Deploy: ");
+        if (at >= 0)
+            tree.write(readme, text.slice(0, at) + nx(text.slice(at)));
+    }
+    return next;
+}

package/utils/detect.d.ts

@@ -0,0 +1,42 @@
+/** Vite config file names Vite itself looks for, in its order. */
+export declare const VITE_CONFIGS: readonly ["vite.config.ts", "vite.config.mts", "vite.config.js", "vite.config.mjs"];
+/** Vitest config file names. */
+export declare const VITEST_CONFIGS: readonly ["vitest.config.ts", "vitest.config.mts", "vitest.config.js", "vitest.config.mjs"];
+export interface ProjectFacts {
+    /** `app`: file-routed (`rivetRouter`); `spa`: `rivet()` compiler plugin without the router; `lib`: Rivet test setup only. */
+    kind: "app" | "spa" | "lib";
+    /** `rivetRouter({ mode: "static" })`: pages are prerendered at build time. */
+    static: boolean;
+    /** `rivetRouter({ mode: "csr" })`: browser-rendered app, no server build. */
+    csr: boolean;
+    /** A vitest config (or a vite config `test` block) with `rivetTest()`. */
+    test: boolean;
+    /** The project has a `tsconfig.json`. */
+    tsconfig: boolean;
+    /** Locales of `@rivetjs/i18n` (`i18n.config.ts` `locales: [...]`): one client build each. */
+    locales?: string[];
+    /** Platform target of `rivetRouter({ adapter: "vercel" | { name: "vercel", … } })` (create-rivet `--deploy`). */
+    adapter?: string;
+    /** The project's own preview server (`serve.js`). */
+    serveScript: boolean;
+    /** The project's own prerender step (`prerender.js`). */
+    prerenderScript: boolean;
+}
+export interface ConfigTexts {
+    vite?: string;
+    vitest?: string;
+    i18n?: string;
+    files: {
+        tsconfig: boolean;
+        serveScript: boolean;
+        prerenderScript: boolean;
+    };
+}
+/** `rivetRouter({ … mode: "static" … })` (the router's `mode` option; the first `rivetRouter(` call). */
+export declare function routerMode(vite: string): string | undefined;
+/** `rivetRouter({ adapter: "x" })` or `rivetRouter({ adapter: { name: "x", … } })`: the platform target name. */
+export declare function routerAdapter(vite: string): string | undefined;
+/** `locales: ["en", "de"]` of an i18n config. */
+export declare function i18nLocales(config: string): string[] | undefined;
+/** The facts of a project from its config texts; `undefined` when it is not a Rivet project. */
+export declare function detectProject(texts: ConfigTexts): ProjectFacts | undefined;

package/utils/detect.js

@@ -0,0 +1,60 @@
+// What kind of Rivet project a folder holds, read from its config files' text (no config is executed: inference
+// must stay fast and side-effect free). Used by the inference plugin, the executors and the generators.
+/** Vite config file names Vite itself looks for, in its order. */
+export const VITE_CONFIGS = ["vite.config.ts", "vite.config.mts", "vite.config.js", "vite.config.mjs"];
+/** Vitest config file names. */
+export const VITEST_CONFIGS = ["vitest.config.ts", "vitest.config.mts", "vitest.config.js", "vitest.config.mjs"];
+const ROUTER = /@rivetjs\/router\/vite|\brivetRouter\s*\(/;
+const COMPILER = /@rivetjs\/compiler\/vite/;
+const TESTING = /@rivetjs\/testing\/vite|\brivetTest\s*\(/;
+const I18N = /@rivetjs\/i18n\/vite/;
+/** `rivetRouter({ … mode: "static" … })` (the router's `mode` option; the first `rivetRouter(` call). */
+export function routerMode(vite) {
+    const at = vite.search(/\brivetRouter\s*\(/);
+    if (at < 0)
+        return undefined;
+    const call = vite.slice(at, at + 2000);
+    return /\bmode\s*:\s*["'`](\w+)["'`]/.exec(call)?.[1];
+}
+/** `rivetRouter({ adapter: "x" })` or `rivetRouter({ adapter: { name: "x", … } })`: the platform target name. */
+export function routerAdapter(vite) {
+    const at = vite.search(/\brivetRouter\s*\(/);
+    if (at < 0)
+        return undefined;
+    const call = vite.slice(at, at + 2000);
+    return /\badapter\s*:\s*(?:\{[^}]*?\bname\s*:\s*)?["'`]([\w-]+)["'`]/.exec(call)?.[1];
+}
+/** `locales: ["en", "de"]` of an i18n config. */
+export function i18nLocales(config) {
+    const list = /\blocales\s*:\s*\[([^\]]*)\]/.exec(config)?.[1];
+    if (list === undefined)
+        return undefined;
+    const locales = [...list.matchAll(/["'`]([^"'`]+)["'`]/g)].map((match) => match[1]);
+    return locales.length ? locales : undefined;
+}
+/** The facts of a project from its config texts; `undefined` when it is not a Rivet project. */
+export function detectProject(texts) {
+    const vite = texts.vite ?? "";
+    const router = ROUTER.test(vite);
+    const compiler = COMPILER.test(vite);
+    const test = TESTING.test(texts.vitest ?? "") || (TESTING.test(vite) && /\btest\s*:/.test(vite));
+    if (!router && !compiler && !test)
+        return undefined;
+    const mode = router ? routerMode(vite) : undefined;
+    const facts = {
+        kind: router ? "app" : compiler ? "spa" : "lib",
+        static: mode === "static",
+        csr: mode === "csr",
+        test,
+        tsconfig: texts.files.tsconfig,
+        serveScript: texts.files.serveScript,
+        prerenderScript: texts.files.prerenderScript,
+    };
+    const adapter = router ? routerAdapter(vite) : undefined;
+    if (adapter)
+        facts.adapter = adapter;
+    const locales = I18N.test(vite) && texts.i18n ? i18nLocales(texts.i18n) : undefined;
+    if (locales)
+        facts.locales = locales;
+    return facts;
+}

package/utils/facts.d.ts

@@ -0,0 +1,8 @@
+import type { Tree } from "@nx/devkit";
+import { type ProjectFacts } from "./detect.js";
+/** Facts of the project in `dir` (absolute) on disk. */
+export declare function projectFacts(dir: string): ProjectFacts | undefined;
+/** Facts of the project at `root` (workspace-relative) in a generator tree. */
+export declare function treeFacts(tree: Tree, root: string): ProjectFacts | undefined;
+/** The Vite config path of a project (workspace-relative in a tree), if any. */
+export declare function viteConfigPath(tree: Tree, root: string): string | undefined;

package/utils/facts.js

@@ -0,0 +1,42 @@
+// Project facts from the file system (executors, the inference plugin) or an Nx `Tree` (generators).
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { detectProject, VITE_CONFIGS, VITEST_CONFIGS } from "./detect.js";
+const disk = {
+    exists: (path) => existsSync(path),
+    read: (path) => (existsSync(path) ? readFileSync(path, "utf8") : undefined),
+};
+function treeReader(tree) {
+    return { exists: (path) => tree.exists(path), read: (path) => (tree.exists(path) ? (tree.read(path, "utf8") ?? undefined) : undefined) };
+}
+/** The first existing file of `names` in `dir`. */
+function first(reader, dir, names) {
+    return names.map((name) => join(dir, name)).find((path) => reader.exists(path));
+}
+function factsWith(reader, dir) {
+    const vite = first(reader, dir, VITE_CONFIGS);
+    const vitest = first(reader, dir, VITEST_CONFIGS);
+    const i18n = first(reader, dir, ["i18n.config.ts", "i18n.config.js", "i18n.config.mts", "i18n.config.mjs"]);
+    return detectProject({
+        ...(vite ? { vite: reader.read(vite) } : {}),
+        ...(vitest ? { vitest: reader.read(vitest) } : {}),
+        ...(i18n ? { i18n: reader.read(i18n) } : {}),
+        files: {
+            tsconfig: reader.exists(join(dir, "tsconfig.json")),
+            serveScript: reader.exists(join(dir, "serve.js")),
+            prerenderScript: reader.exists(join(dir, "prerender.js")),
+        },
+    });
+}
+/** Facts of the project in `dir` (absolute) on disk. */
+export function projectFacts(dir) {
+    return factsWith(disk, dir);
+}
+/** Facts of the project at `root` (workspace-relative) in a generator tree. */
+export function treeFacts(tree, root) {
+    return factsWith(treeReader(tree), root);
+}
+/** The Vite config path of a project (workspace-relative in a tree), if any. */
+export function viteConfigPath(tree, root) {
+    return first(treeReader(tree), root, VITE_CONFIGS);
+}

package/utils/project.d.ts

@@ -0,0 +1,28 @@
+import { type Tree } from "@nx/devkit";
+import type { ProjectFacts } from "./detect.js";
+export interface RivetProject {
+    name: string;
+    root: string;
+    /** `<root>/src` (or the project's sourceRoot). */
+    src: string;
+    /** `<src>/routes`. */
+    routes: string;
+    facts: ProjectFacts | undefined;
+    /** A library (`projectType: library`, or no Vite config). */
+    library: boolean;
+}
+export declare function rivetProject(tree: Tree, name: string): RivetProject;
+/** Throws unless the project is a file-routed Rivet app (`rivetRouter()` in its Vite config). */
+export declare function routedApp(tree: Tree, name: string, generator: string): RivetProject;
+/** Route path → segments: `blog/[slug]` → `["blog", "[slug]"]` (leading `/`, `src/routes/`, extension and `index` dropped). */
+export declare function routeSegments(path: string): string[];
+/** Params of route segments: `[slug]` → `{ name: "slug", kind: "one" }`. */
+export interface RouteParam {
+    name: string;
+    kind: "one" | "optional" | "rest";
+}
+export declare function routeParams(segments: string[]): RouteParam[];
+/** `PascalCase` name of route segments (`blog/[slug]` → `BlogSlug`; root → `Home`). */
+export declare function routeComponentName(segments: string[]): string;
+/** `../` from a file in `dir` (workspace-relative) back to `to`. */
+export declare function relativeImport(fromDir: string, to: string): string;