+
+{/* ── Scrollable nav ─────────────────────────────────────────────── */}
+
+
+
+
+{/* ── Bottom bar (all breakpoints) ────────────────────────────────── */}
+
+
+
+
+
+
+
+
diff --git a/docs/gonx-docs/src/components/ThemeSelect.astro b/docs/gonx-docs/src/components/ThemeSelect.astro
new file mode 100644
index 000000000..67194cb22
--- /dev/null
+++ b/docs/gonx-docs/src/components/ThemeSelect.astro
@@ -0,0 +1,119 @@
+---
+---
+
+
+
+
+
+{/* Inlined to avoid FOUC. Uses global scope from ThemeProvider.astro */}
+
+
+
+
+
diff --git a/docs/gonx-docs/src/content/docs/community/contributing.md b/docs/gonx-docs/src/content/docs/community/contributing.md
new file mode 100644
index 000000000..2fc0ff5da
--- /dev/null
+++ b/docs/gonx-docs/src/content/docs/community/contributing.md
@@ -0,0 +1,99 @@
+---
+title: Contributing
+description: How to contribute to @naxodev/gonx.
+---
+
+gonx is MIT licensed and developed on
+[GitHub](https://github.com/naxodev/oss/tree/main/packages/gonx). Bug reports,
+feature requests, and pull requests are all welcome.
+
+## Development setup
+
+This repo is a [bun](https://bun.sh/) workspace with Nx. Clone it and install
+dependencies:
+
+```bash
+git clone https://github.com/naxodev/oss.git
+cd oss
+bun install
+```
+
+You need:
+
+- **Node.js 22+**
+- **bun** (package manager)
+- **Go** — a stable release (for running e2e tests)
+
+## Running tests
+
+Unit tests run on `bun test`. Run a single spec directly:
+
+```bash
+cd packages/gonx && bun test src/graph/static-analysis/parse-go-mod.spec.ts
+```
+
+Or run the whole project through Nx (each spec runs in its own bun process for
+mock isolation):
+
+```bash
+bunx nx test gonx
+```
+
+End-to-end tests spin up a local Verdaccio registry and install the published
+tarball into a generated workspace:
+
+```bash
+bunx nx e2e gonx-e2e
+```
+
+## Linting and formatting
+
+```bash
+bunx nx lint gonx
+bunx nx format:check
+bunx nx format:write
+```
+
+## Opening a pull request
+
+1. Create a branch from `main`.
+2. Make your changes, keeping commits focused.
+3. Run lint, tests, and build before pushing:
+
+ ```bash
+ bunx nx affected -t lint test build
+ ```
+
+4. Open a PR with a clear description.
+
+### Commit messages
+
+Commits are validated by **commitlint** using Conventional Commits. Use the
+package scope:
+
+```
+feat(gonx): add new generator option
+fix(gonx): resolve import edge case
+docs(gonx): update executor reference
+```
+
+PR titles matter — squash-merge lands the PR title as the commit subject. Use
+`feat(gonx)!: ...` for breaking changes.
+
+### Coding rules
+
+- All features or bug fixes must be covered by one or more unit tests.
+- All public API methods must be documented.
+
+## Releasing
+
+Releases are independent per project and published manually from a maintainer's
+machine (the npm account requires 2FA for writes). See
+[CONTRIBUTING.md](https://github.com/naxodev/oss/blob/main/CONTRIBUTING.md) for
+the full release workflow.
+
+## Next steps
+
+- [How static analysis works](/understanding/static-analysis) — understand the tree-sitter graph
+- [Plugin options](/guides/generators/options) — the plugin's configuration surface
+- [Quick start](/getting-started/quick-start) — get familiar with gonx as a user
diff --git a/docs/gonx-docs/src/content/docs/community/migration.md b/docs/gonx-docs/src/content/docs/community/migration.md
new file mode 100644
index 000000000..024761aba
--- /dev/null
+++ b/docs/gonx-docs/src/content/docs/community/migration.md
@@ -0,0 +1,115 @@
+---
+title: Migrate to gonx 3.0.0
+description: How to migrate from nx-go or upgrade to @naxodev/gonx 3.0.0.
+---
+
+import { Steps } from '@astrojs/starlight/components';
+
+gonx 3.0.0 requires Nx 23 and infers Go targets from `go.mod` files instead of
+generating `project.json` targets. Adapt your workspace with the steps below.
+
+## Before you start
+
+- **Nx 23.x** or later
+- **Go** — a stable release (1.18+ for multi-module workspaces)
+- A backup of your workspace
+
+## Steps
+
+
+1. **Upgrade to Nx 23**
+ ```bash
+ npx nx migrate latest
+ npx nx migrate --run-migrations
+ ```
+ gonx 3.0.0 requires Nx 23.x. If you are already on 23, skip this step.
+
+2. **Remove nx-go and install gonx**
+ If migrating from [@nx-go/nx-go](https://github.com/nx-go/nx-go), uninstall it
+ first:
+
+ ```bash
+ npm uninstall @nx-go/nx-go
+ ```
+
+ Then install gonx and apply its migrations:
+
+ ```bash
+ npx nx add @naxodev/gonx
+ ```
+
+ If you are upgrading from an earlier gonx release, `nx add` picks up the
+ migration prompts automatically.
+
+3. **Register the gonx plugin in `nx.json`**
+
+ ```json
+ {
+ "plugins": ["@naxodev/gonx"]
+ }
+ ```
+
+ Remove any nx-go plugin entry. gonx infers targets from `go.mod`, so no
+ per-project config is needed.
+
+4. **Delete hand-written Go targets**
+ gonx infers `build`, `serve`, `test`, `lint`, `tidy`, and `generate` from each
+ `go.mod`. The main package is auto-detected — a project with `package main`
+ and `func main()` in `main.go`, or a `cmd/` directory, is treated as an
+ application and gets `build` and `serve` targets. Remove `project.json` files
+ that hand-write those targets:
+
+ ```bash
+ rm apps/my-go-app/project.json
+ ```
+
+ Keep `project.json` only for non-Go projects or custom overrides. gonx uses
+ the full project root path as the project name (for example,
+ `apps/my-go-app`), not just the final directory segment — this aligns with
+ Go's release tagging convention (`projectRoot/vx.x.x`). Update any scripts or
+ CI that reference short project names.
+
+5. **Remove the `cwd` serve option and review `cmd`/`compiler` values**
+ The `cwd` serve option no longer exists — serve runs from the project root.
+ Delete `options.cwd` from any hand-written serve target. Because the main
+ package is auto-detected, `options.main` is optional. The serve `cmd` and
+ build `compiler` options now accept `gow` alongside `go` and `tinygo`. See
+ the [serve executor guide](/guides/executors/serve) and
+ [build executor guide](/guides/executors/build).
+
+6. **Decide whether to keep `go.work`**
+ gonx no longer creates a `go.work` file by default. Build and serve work
+ without one. Keep an existing `go.work` only if you intentionally use a
+ multi-module workspace. To opt in when initializing gonx:
+
+ ```bash
+ npx nx g @naxodev/gonx:init --addGoDotWork
+ ```
+
+7. **Remove `convert-to-one-mod` usage**
+ The `convert-to-one-mod` generator was removed. Delete any script or doc that
+ invokes `nx g @naxodev/gonx:convert-to-one-mod`. Consolidate modules manually
+ with standard Go tooling.
+
+
+## Verify
+
+Confirm Nx detects your Go projects and infers their targets:
+
+```bash
+npx nx show projects
+npx nx show project apps/my-go-app
+```
+
+`nx show project` lists the inferred targets with no leftover `cwd` options.
+Then build a project to confirm it works without `go.work`:
+
+```bash
+npx nx build apps/my-go-app
+```
+
+## Next steps
+
+- [Plugin options](/guides/generators/options) — customize target names and tags
+- [Create your first Go project](/tutorials/first-go-project) — walkthrough of generators and executors
+- [nx-release-publish executor](/guides/executors/nx-release-publish) — publish Go modules
diff --git a/docs/gonx-docs/src/content/docs/executors/build.md b/docs/gonx-docs/src/content/docs/executors/build.md
deleted file mode 100644
index 4d8c47131..000000000
--- a/docs/gonx-docs/src/content/docs/executors/build.md
+++ /dev/null
@@ -1,58 +0,0 @@
----
-title: Build Executor
-description: Builds a Go project using the Go compiler
----
-
-## Usage
-
-```bash
-nx build my-go-app
-```
-
-## Options
-
-| Option | Type | Default | Description |
-| ---------- | -------- | ------------------- | --------------------------------------------------------------------------- |
-| main | string | - | Relative path from the project root to the main.go file defining the binary |
-| compiler | string | "go" | The Go compiler to use (possible values: 'go', 'tinygo') |
-| outputPath | string | dist/{project-root} | The output path of the resulting executable |
-| buildMode | string | - | Build mode to use |
-| env | object | - | Environment variables to set when running the executor |
-| flags | string[] | - | Flags to pass to the go compiler |
-
-## Default Inferred
-
-```json
-{
- "executor": "@naxodev/gonx:build",
- "cache": true,
- "inputs": ["{projectRoot}/go.mod", "{projectRoot}/go.sum", "{projectRoot}/**/*.{go}"],
- "options": {
- "outputPath": "dist/{projectRoot}"
- },
- "outputs": ["{options.outputPath}"]
-}
-```
-
-## Examples
-
-### Build with default main.go
-
-```bash
-nx build my-go-app
-```
-
-### Build with custom main file
-
-```bash
-nx build my-go-app --main=cmd/server/main.go
-```
-
-This will build the application using the main.go file located at `cmd/server/main.go` relative to the project root.
-
-## Notes
-
-- The build executor is cacheable, so subsequent builds with the same inputs will be faster
-- Uses the official Go compiler in the background by default but the compiler can be overridden to use `tinygo` or any other Go compiler
-- When `main` option is specified, the build command runs from the directory containing the main.go file
-- If no `main` option is provided, the build command will discover and build all main packages in the project
diff --git a/docs/gonx-docs/src/content/docs/executors/generate.md b/docs/gonx-docs/src/content/docs/executors/generate.md
deleted file mode 100644
index a311c1779..000000000
--- a/docs/gonx-docs/src/content/docs/executors/generate.md
+++ /dev/null
@@ -1,66 +0,0 @@
----
-title: Generate Executor
-description: Runs code generation using the `go generate` command
----
-
-## Usage
-
-```bash
-nx run my-go-app:generate
-```
-
-> **Note**: Use `nx run :generate` instead of `nx generate ` to avoid conflicts with Nx's native generator commands.
-
-## Options
-
-| Option | Type | Default | Description |
-| ------ | -------- | ------- | ------------------------------------------------------ |
-| env | object | - | Environment variables to set when running the executor |
-| flags | string[] | - | Flags to pass to the go generate command |
-
-## Default Inferred
-
-```json
-{
- "executor": "@naxodev/gonx:generate",
- "cache": true,
- "dependsOn": ["^generate"],
- "inputs": ["{projectRoot}/go.mod", "{projectRoot}/go.sum", "{projectRoot}/**/*.{go}"]
-}
-```
-
-## Examples
-
-### Basic code generation
-
-```bash
-nx run my-go-app:generate
-```
-
-### Generate with verbose output
-
-```bash
-nx run my-go-app:generate --flags=-v
-```
-
-### Generate with multiple flags
-
-```bash
-nx run my-go-app:generate --flags=-v --flags=-x
-```
-
-### Generate with custom environment variables
-
-```bash
-nx run my-go-app:generate --env.GOOS=linux --env.GOARCH=amd64
-```
-
-## Notes
-
-- The generate executor is cacheable, so subsequent runs with the same inputs will be faster
-- Uses the official `go generate` command in the background
-- The generate executor automatically runs before build and test operations due to dependency configuration
-- The command searches for `//go:generate` directives in all Go files within the project and its subdirectories
-- Generated files should be committed to version control if they are needed for builds
-- The executor runs `go generate ./...` to process all packages in the project tree
-- **Important**: Always use `nx run :generate` syntax to avoid conflicts with Nx's `nx generate` command for generators
diff --git a/docs/gonx-docs/src/content/docs/executors/lint.md b/docs/gonx-docs/src/content/docs/executors/lint.md
deleted file mode 100644
index 9a08723b3..000000000
--- a/docs/gonx-docs/src/content/docs/executors/lint.md
+++ /dev/null
@@ -1,49 +0,0 @@
----
-title: Lint Executor
-description: Formats and lints a Go project
----
-
-## Usage
-
-```bash
-nx lint my-go-app
-```
-
-## Options
-
-| Option | Type | Default | Description |
-| ------ | -------- | -------- | ---------------------------------------- |
-| linter | string | "go fmt" | The command to execute instead of go fmt |
-| args | string[] | - | Extra args when linting the project |
-
-## Default Inferred
-
-```json
-{
- "executor": "@naxodev/gonx:lint",
- "cache": true,
- "inputs": ["{projectRoot}/go.mod", "{projectRoot}/go.sum", "{projectRoot}/**/*.{go}"]
-}
-```
-
-### Using golangci-lint
-
-```json
-"@naxodev/gonx:lint": {
- "cache": true,
- "inputs": [
- "{projectRoot}/go.mod",
- "{projectRoot}/go.sum",
- "{projectRoot}/**/*.{go}"
- ],
- "options": {
- "linter": "golangci-lint run"
- }
-},
-```
-
-## Notes
-
-- The lint executor is cacheable
-- You can customize the linting tool (for example, use gofmt or golangci-lint instead of go fmt)
-- Uses the official Go tooling in the background
diff --git a/docs/gonx-docs/src/content/docs/executors/nx-release-publish.md b/docs/gonx-docs/src/content/docs/executors/nx-release-publish.md
deleted file mode 100644
index 74e094e28..000000000
--- a/docs/gonx-docs/src/content/docs/executors/nx-release-publish.md
+++ /dev/null
@@ -1,42 +0,0 @@
----
-title: Nx-Release-Publish Executor
-description: Lists the module in the Golang registry
----
-
-## Usage
-
-```bash
-nx nx-release-publish my-go-lib
-```
-
-or through the `nx release` command:
-
-```bash
-nx release --publish
-```
-
-## Options
-
-The nx-release-publish executor does not have configurable options. It automatically publishes your Go module to the Go registry.
-
-## Default Inferred
-
-```json
-{
- executor: '@naxodev/gonx:release-publish',
- options: {
- moduleRoot: projectRoot,
- },
- configurations: {
- development: {
- dryRun: true,
- },
- },
- }
-```
-
-## Notes
-
-- This executor is designed to work seamlessly with `nx release`
-- Publishes your Go module to the Go registry
-- Part of gonx's integration with Nx's version management system
diff --git a/docs/gonx-docs/src/content/docs/executors/serve.md b/docs/gonx-docs/src/content/docs/executors/serve.md
deleted file mode 100644
index 7f19700ca..000000000
--- a/docs/gonx-docs/src/content/docs/executors/serve.md
+++ /dev/null
@@ -1,58 +0,0 @@
----
-title: Serve Executor
-description: Runs a Go application
----
-
-## Usage
-
-```bash
-nx serve my-go-app
-```
-
-## Options
-
-| Option | Type | Default | Description |
-| ------ | -------- | ------- | --------------------------------------------------------------------------- |
-| main | string | - | Relative path from the project root to the main.go file defining the binary |
-| cmd | string | "go" | Name of the go binary to use |
-| args | string[] | - | Extra args when starting the app |
-| env | object | - | Environment variables to set when running the application |
-
-## Default Inferred
-
-```json
-{
- "executor": "@naxodev/gonx:serve",
- "continuous": true,
- "options": {}
-}
-```
-
-## Examples
-
-### Serve with default main.go
-
-```bash
-nx serve my-go-app
-```
-
-### Serve with custom main file
-
-```bash
-nx serve my-go-app --main=cmd/server/main.go
-```
-
-This will run the application using the main.go file located at `cmd/server/main.go` relative to the project root.
-
-### Serve with arguments
-
-```bash
-nx serve my-go-app --args="--port=8080,--debug"
-```
-
-## Notes
-
-- Automatically discovers `main.go` files when no explicit main file is specified
-- Uses the official `go run` commands in the background, but it can be overridden to use any other command
-- When `main` option is specified, the serve command runs from the directory containing the main.go file
-- If no `main` option is provided, the serve command will discover and run the main package in the project root
diff --git a/docs/gonx-docs/src/content/docs/executors/test.md b/docs/gonx-docs/src/content/docs/executors/test.md
deleted file mode 100644
index d362db42a..000000000
--- a/docs/gonx-docs/src/content/docs/executors/test.md
+++ /dev/null
@@ -1,39 +0,0 @@
----
-title: Test Executor
-description: Runs tests for a Go project
----
-
-## Usage
-
-```bash
-nx test my-go-app
-```
-
-## Options
-
-| Option | Type | Default | Description |
-| ------------ | ------- | ------- | ---------------------------------------------------------------- |
-| cover | boolean | false | Enable coverage analysis |
-| coverProfile | string | - | Write a coverage profile to the file after all tests have passed |
-| race | boolean | false | Enable race detector |
-| run | string | - | Run only tests matching this regular expression |
-| verbose | boolean | false | Enable verbose test output |
-| count | number | - | Run test N times |
-| timeout | string | "10m" | Test timeout duration (0 to disable) |
-
-## Default Inferred
-
-```json
-{
- "executor": "@naxodev/gonx:test",
- "cache": true,
- "dependsOn": ["^build"],
- "inputs": ["{projectRoot}/go.mod", "{projectRoot}/go.sum", "{projectRoot}/**/*.{go}"]
-}
-```
-
-## Notes
-
-- The test executor is cacheable, so subsequent test runs with the same test code will be faster
-- Uses the official Go test command in the background
-- Supports all common Go test options
diff --git a/docs/gonx-docs/src/content/docs/executors/tidy.md b/docs/gonx-docs/src/content/docs/executors/tidy.md
deleted file mode 100644
index 0ae2a32a1..000000000
--- a/docs/gonx-docs/src/content/docs/executors/tidy.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: Tidy Executor
-description: Ensures go.mod file matches the project's source code
----
-
-## Usage
-
-```bash
-nx tidy my-go-app
-```
-
-## Options
-
-| Option | Type | Default | Description |
-| ------- | ------- | ------- | --------------------- |
-| verbose | boolean | false | Enable verbose output |
-
-## Default Inferred
-
-```json
-{
- "executor": "@naxodev/gonx:tidy",
- "cache": true,
- "inputs": ["{projectRoot}/go.mod", "{projectRoot}/go.sum", "{projectRoot}/**/*.{go}"]
-}
-```
-
-## Notes
-
-- The tidy executor is cacheable
-- Uses the official Go mod tidy command in the background
-- Ensures that the go.mod file accurately reflects your project dependencies
diff --git a/docs/gonx-docs/src/content/docs/generators/application.md b/docs/gonx-docs/src/content/docs/generators/application.md
deleted file mode 100644
index 0df0c3bc3..000000000
--- a/docs/gonx-docs/src/content/docs/generators/application.md
+++ /dev/null
@@ -1,112 +0,0 @@
----
-title: Application Generator
-description: Generates a Go application with a well-structured foundation
----
-
-## Usage
-
-```bash
-nx g @naxodev/gonx:application my-go-app
-```
-
-## Options
-
-| Option | Type | Default | Description |
-| ---------- | ---------------------------- | ---------- | ---------------------------------------------- |
-| name | string | null | Name of the Go application |
-| directory | string | \*required | The directory of the new application |
-| template | `standard` \| `cli` \| `tui` | `standard` | The template of application to generate |
-| tags | string | null | Add tags to the application (used for linting) |
-| skipFormat | boolean | false | Skip formatting files |
-
-## Examples
-
-### Generate a standard application (default)
-
-```bash
-nx g @naxodev/gonx:application my-go-app
-```
-
-### Generate a CLI application
-
-```bash
-nx g @naxodev/gonx:application my-cli-app --template=cli
-```
-
-### Generate a TUI application
-
-```bash
-nx g @naxodev/gonx:application my-tui-app --template=tui
-```
-
-### Generate an application in a specific directory
-
-```bash
-nx g @naxodev/gonx:application apps/my-go-app
-```
-
-or
-
-```bash
-nx g @naxodev/gonx:application --name=go-app --directory=apps/my-go-app
-```
-
-### Generate an application with tags
-
-> [!NOTE]
-> Tags will only work when the project was created with a project.json file
-
-```bash
-nx g @naxodev/gonx:application my-go-app --tags="json yaml"
-```
-
-## Output
-
-The generator creates different structures based on the application template:
-
-### Standard Application (default)
-
-```
-my-go-app/
-├── main.go
-├── main_test.go
-└── go.mod
-```
-
-### CLI Application (--template=cli)
-
-```
-my-cli-app/
-├── main.go
-├── main_test.go
-├── go.mod
-└── cmd/
- ├── root.go
- ├── version.go
- └── cmd_test.go
-```
-
-### TUI Application (--template=tui)
-
-```
-my-tui-app/
-├── main.go
-├── main_test.go
-├── go.mod
-├── cmd/
- └── root.go
-└── internal/
- └── models/
- ├── model.go
- ├── model_test.go
- └── styles/
- ├── styles.go
-```
-
-## Notes
-
-- Unlike the original nx-go, gonx does not generate a project.json file
-- Uses inferred tasks, so you can immediately use `nx build`, `nx serve`, etc.
-- **CLI applications** use [Cobra](https://github.com/spf13/cobra) for professional command-line interfaces
-- **TUI applications** use [Bubble Tea](https://github.com/charmbracelet/bubbletea) and [Lipgloss](https://github.com/charmbracelet/lipgloss) for interactive terminal UIs
-- For CLI and TUI apps, run `nx tidy ` after generation to download dependencies
diff --git a/docs/gonx-docs/src/content/docs/generators/go-blueprint.md b/docs/gonx-docs/src/content/docs/generators/go-blueprint.md
deleted file mode 100644
index 74ee2a236..000000000
--- a/docs/gonx-docs/src/content/docs/generators/go-blueprint.md
+++ /dev/null
@@ -1,206 +0,0 @@
----
-title: Go Blueprint Generator
-description: Uses [Go Blueprint](https://github.com/Melkeydev/go-blueprint) to generate Go applications with various frameworks and features. This generator integrates Go Blueprint's powerful scaffolding capabilities with Nx's workflow
----
-
-The Go Blueprint binary is included with this package, so no additional installation is required.
-
-## Usage
-
-```bash
-nx g @naxodev/gonx:go-blueprint my-go-app
-```
-
-The generator will prompt you to select:
-
-- Web framework
-- Database driver
-- Git handling preference
-- Advanced features (optional)
-
-## Options
-
-| Option | Type | Default | Description |
-| ------------ | ------- | ---------- | ------------------------------------------ |
-| directory | string | \*required | The directory of the new application |
-| name | string | null | The name of the application |
-| tags | string | null | Add tags to the project (used for linting) |
-| skipFormat | boolean | false | Skip formatting files |
-| addGoDotWork | boolean | false | Add this project to go.work file |
-| framework | string | \*required | Web framework to use |
-| driver | string | \*required | Database driver to use |
-| git | string | \*required | Git handling preference |
-| feature | array | [] | Advanced features to include |
-
-### Framework Options
-
-- `chi` - Chi router
-- `gin` - Gin web framework
-- `fiber` - Fiber web framework
-- `gorilla/mux` - Gorilla Mux router
-- `httprouter` - HttpRouter
-- `standard-library` - Go standard library
-- `echo` - Echo web framework
-
-### Database Driver Options
-
-- `mysql` - MySQL database
-- `postgres` - PostgreSQL database
-- `sqlite` - SQLite database
-- `mongo` - MongoDB
-- `redis` - Redis
-- `scylla` - ScyllaDB
-- `none` - No database
-
-### Git Options
-
-- `commit` - Initialize git and commit changes
-- `stage` - Initialize git and stage changes
-- `skip` - Skip git initialization
-
-### Advanced Features
-
-- `react` - React frontend integration (⚠️ **Not recommended** - see Frontend Integration below)
-- `htmx` - HTMX integration
-- `githubaction` - GitHub Actions workflow
-- `websocket` - WebSocket support
-- `tailwind` - Tailwind CSS
-- `docker` - Docker configuration
-
-## Examples
-
-### Basic Usage with Prompts
-
-```bash
-nx g @naxodev/gonx:go-blueprint my-api
-```
-
-This will prompt you to select all required options interactively.
-
-### Specify All Options
-
-```bash
-nx g @naxodev/gonx:go-blueprint my-api \
- --framework=gin \
- --driver=postgres \
- --git=commit \
- --feature=docker,githubaction
-```
-
-### Generate in Specific Directory
-
-```bash
-nx g @naxodev/gonx:go-blueprint apps/my-api \
- --framework=fiber \
- --driver=mysql \
- --git=stage
-```
-
-### Add to Go Workspace
-
-```bash
-nx g @naxodev/gonx:go-blueprint my-service \
- --framework=chi \
- --driver=none \
- --git=skip \
- --addGoDotWork=true
-```
-
-## Output
-
-The generator creates a fully-featured Go application based on your selections. The exact structure depends on the chosen framework and features, but typically includes:
-
-```
-my-go-app/
-├── main.go
-├── go.mod
-├── go.sum
-├── handlers/
-├── models/
-├── database/
-├── static/
-└── ... (additional files based on selected features)
-```
-
-## Integration with Nx
-
-After generation, you can use all standard Nx commands:
-
-```bash
-# Build the application
-nx build my-go-app
-
-# Run the application
-nx serve my-go-app
-
-# Run tests
-nx test my-go-app
-
-# Lint the code
-nx lint my-go-app
-
-# Manage dependencies
-nx tidy my-go-app
-```
-
-## Frontend Integration
-
-:::caution
-Avoid using Go Blueprint's built-in frontend features (like `react`) as they will not be properly detected by Nx's project graph. Since Nx already detects a Go project in the directory, adding frontend code directly will create conflicts.
-:::
-
-### Recommended Approach
-
-Instead of using Go Blueprint's frontend features, create separate frontend projects using Nx's native generators:
-
-```bash
-# Generate your Go API first
-nx g @naxodev/gonx:go-blueprint my-api --framework=gin --driver=postgres --git=skip
-
-# Then generate a separate frontend project
-nx g @nx/react:app frontend --directory=apps/frontend
-
-# Or use other Nx frontend generators
-nx g @nx/angular:app frontend --directory=apps/frontend
-nx g @nx/vue:app frontend --directory=apps/frontend
-```
-
-### Benefits of Separate Projects
-
-- ✅ Proper Nx project graph detection and dependency tracking
-- ✅ Independent build, test, and deployment pipelines
-- ✅ Better separation of concerns
-- ✅ Full access to Nx's frontend tooling and optimizations
-- ✅ Easier to scale and maintain
-
-### Example Workspace Structure
-
-```
-my-workspace/
-├── apps/
-│ ├── my-api/ # Go API (generated with go-blueprint)
-│ │ ├── main.go
-│ │ └── go.mod
-│ └── frontend/ # React/Angular/Vue app (generated with Nx)
-│ ├── src/
-│ └── package.json
-└── nx.json
-```
-
-## Notes
-
-- Go Blueprint binary is bundled with this package
-- Uses Nx's inferred tasks, so no project.json file is generated
-- Follows gonx's philosophy of keeping non-JS monorepos pure
-- All Go Blueprint options are mapped to provide a seamless integration experience
-
-## Troubleshooting
-
-### Generation Fails
-
-If generation fails:
-
-1. Check that the target directory doesn't already exist
-2. Ensure you have write permissions to the target location
-3. Verify all required options are provided
-4. Check [Go Blueprint documentation](https://docs.go-blueprint.dev/) for framework-specific requirements
diff --git a/docs/gonx-docs/src/content/docs/generators/init.md b/docs/gonx-docs/src/content/docs/generators/init.md
deleted file mode 100644
index 8c870cadb..000000000
--- a/docs/gonx-docs/src/content/docs/generators/init.md
+++ /dev/null
@@ -1,32 +0,0 @@
----
-title: Init Generator
-description: Initializes gonx in an existing Nx workspace
----
-
-:::caution
-This is an internal generator, not intended to be use directly as Nx does.
-:::
-
-## Usage
-
-```bash
-nx g @naxodev/gonx:init
-```
-
-## Options
-
-This generator does not have configurable options.
-
-## Example
-
-```bash
-nx g @naxodev/gonx:init
-```
-
-## Notes
-
-- Sets up the workspace for Go development
-- Configures the workspace for Go development
-- Can be used with `nx add @naxodev/gonx` to add gonx to an existing workspace
-- Creates the necessary configuration files for Go development
-- Creates go.work file only when explicitly requested via the `addGoDotWork` option
diff --git a/docs/gonx-docs/src/content/docs/generators/library.md b/docs/gonx-docs/src/content/docs/generators/library.md
deleted file mode 100644
index ec7b9106e..000000000
--- a/docs/gonx-docs/src/content/docs/generators/library.md
+++ /dev/null
@@ -1,61 +0,0 @@
----
-title: Library Generator
-description: Generates a Go library with a well-structured foundation
----
-
-## Usage
-
-```bash
-nx g @naxodev/gonx:library my-go-lib
-```
-
-## Options
-
-| Option | Type | Default | Description |
-| ---------- | ------- | ---------- | ------------------------------------------ |
-| name | string | null | Name of the Go library |
-| directory | string | \*required | The directory of the new library |
-| tags | string | null | Add tags to the library (used for linting) |
-| skipFormat | boolean | false | Skip formatting files |
-
-## Examples
-
-### Generate a library in the root
-
-```bash
-nx g @naxodev/gonx:library my-go-lib
-```
-
-### Generate a library in a specific directory
-
-```bash
-nx g @naxodev/gonx:library libs/my-go-lib
-```
-
-### Generate a library with tags
-
-> [!NOTE]
-> Tags will only work when the project was created with a project.json file
-
-```bash
-nx g @naxodev/gonx:library my-go-lib --tags="json yaml"
-```
-
-## Output
-
-The generator creates a Go library with the following structure:
-
-```
-my-go-lib/
-├── go.mod
-├── go.sum
-├── my-go-lib.go
-└── my-go-lib.go_test.go
-```
-
-## Notes
-
-- Unlike the original nx-go, gonx does not generate a project.json file
-- Uses inferred tasks, so you can immediately use `nx build`, `nx test`, etc.
-- Works with both single and multi-module Go workspace configurations
-- Integrated with Nx release system for version management
diff --git a/docs/gonx-docs/src/content/docs/generators/options.md b/docs/gonx-docs/src/content/docs/generators/options.md
deleted file mode 100644
index 751f558c0..000000000
--- a/docs/gonx-docs/src/content/docs/generators/options.md
+++ /dev/null
@@ -1,180 +0,0 @@
----
-title: Configuration Options
-description: gonx provides several configuration options to customize your Go development experience within Nx
----
-
-## Workspace Configuration
-
-By default, gonx sets up projects without creating a go.work file, keeping the workspace lightweight. You can enable multi-module Go workspace configuration by using the `addGoDotWork` option when setting up your workspace, which provides better integration with Nx's dependency graph and caching features for complex Go projects.
-
-## Inferred Tasks
-
-gonx leverages Nx's inferred tasks feature, which means you don't need to have project.json files for your Go projects. The following tasks are automatically available:
-
-| Task | Command | Description |
-| -------- | ----------------------- | ----------------------------------------- |
-| build | `nx build ` | Builds the Go application |
-| generate | `nx run :generate` | Runs code generation using go generate |
-| serve | `nx serve ` | Runs the Go application |
-| test | `nx test ` | Runs tests for the Go project |
-| lint | `nx lint ` | Formats and lints the Go project |
-| tidy | `nx tidy ` | Ensures go.mod matches the project source |
-| publish | (with nx release) | Publishes the Go module to the registry |
-
-## Nx Release Integration
-
-gonx integrates with Nx's release system, providing:
-
-1. Version management for Go modules
-2. Publishing to the Go registry
-3. Semantic versioning support
-
-To use this feature, you can run:
-
-```bash
-nx release
-```
-
-This will handle versioning and publishing your Go modules.
-
-## Custom Task Configuration
-
-If you want to override the default inferred task configuration, you can create a project.json file in your Go project directory with custom executor options. This gives you fine-grained control while still benefiting from gonx's integration with Nx.
-
-Example project.json:
-
-```json
-{
- "name": "my-go-app",
- "$schema": "../../node_modules/nx/schemas/project-schema.json",
- "targets": {
- "build": {
- "executor": "@naxodev/gonx:build",
- "options": {
- "main": "my-go-app/cmd/my-go-app/main.go",
- "outputPath": "dist/apps/my-go-app",
- "env": {
- "GOOS": "linux",
- "GOARCH": "amd64"
- }
- }
- }
- }
-}
-```
-
-Or if you want to stay project-less you can configure it in the `nx.json`
-
-```json
-{
- ...
- "targetDefaults": {
- ...
- "@naxodev/gonx:lint": {
- "cache": true,
- "inputs": ["{projectRoot}/go.mod", "{projectRoot}/go.sum", "{projectRoot}/**/*.{go}"],
- "options": {
- "linter": "golangci-lint run"
- }
- }
- }
-}
-```
-
-## Environment Variables
-
-You can configure environment variables for Go commands using the `env` option in the executor configuration:
-
-```json
-{
- "build": {
- "executor": "@naxodev/gonx:build",
- "options": {
- "main": "my-go-app/cmd/my-go-app/main.go",
- "env": {
- "GOOS": "linux",
- "GOARCH": "amd64"
- }
- }
- }
-}
-```
-
-## Compiler Options
-
-For the build executor, you can choose between the standard Go compiler and TinyGo using the `compiler` option:
-
-```json
-{
- "build": {
- "executor": "@naxodev/gonx:build",
- "options": {
- "main": "my-go-app/cmd/my-go-app/main.go",
- "compiler": "tinygo"
- }
- }
-}
-```
-
-## Custom Linting
-
-You can configure custom linting tools instead of the default `go fmt`:
-
-```json
-{
- "lint": {
- "executor": "@naxodev/gonx:lint",
- "options": {
- "linter": "golangci-lint",
- "args": ["run"]
- }
- }
-}
-```
-
-## Code Generation
-
-You can configure the generate executor with custom flags and environment variables:
-
-```json
-{
- "generate": {
- "executor": "@naxodev/gonx:generate",
- "options": {
- "flags": ["-v"],
- "env": {
- "GOOS": "linux",
- "GOARCH": "amd64"
- }
- }
- }
-}
-```
-
-# Plugin Options
-
-The plugin allows to configure its behavior with global options.
-
-## Usage
-
-Import the plugin with an object instead of a simple string in your `nx.json` file.
-
-Here is an example:
-
-```json
-{
- "$schema": "./node_modules/nx/schemas/nx-schema.json",
- "plugins": [
- {
- "plugin": "@naxodev/gonx",
- "options": { "skipGoDependencyCheck": true }
- }
- ]
-}
-```
-
-## Options
-
-### skipGoDependencyCheck
-
-- (boolean): if true, the plugin will not require to have Go installed to compute a Nx workspace graph. Be aware that if Go is not installed, the plugin will not be able to detect dependencies between Go projects and this is source of misunderstanding.
diff --git a/docs/gonx-docs/src/content/docs/generators/preset.md b/docs/gonx-docs/src/content/docs/generators/preset.md
deleted file mode 100644
index 0eb433b5e..000000000
--- a/docs/gonx-docs/src/content/docs/generators/preset.md
+++ /dev/null
@@ -1,167 +0,0 @@
----
-title: Preset Generator
-description: Preset generator for creating a new workspace with gonx pre-configured. Choose between different project types to bootstrap your Go development
----
-
-## Usage
-
-```bash
-npx create-nx-workspace go-workspace --preset=@naxodev/gonx
-```
-
-When you run this command, you'll be prompted to select a template type:
-
-- **Binary** - Creates a Go application using the standard gonx generator
-- **Library** - Creates a Go library using the gonx library generator
-- **Go Blueprint** - Creates a Go application using Go Blueprint templates
-
-## Options
-
-| Option | Type | Default | Description |
-| ------------ | ------- | ---------- | -------------------------------------------------- |
-| type | string | "binary" | Template type: "binary", "library", "go-blueprint" |
-| directory | string | \*required | The directory of the new project |
-| name | string | null | The name of the project |
-| tags | string | null | Add tags to the project (used for linting) |
-| skipFormat | boolean | false | Skip formatting files |
-| addGoDotWork | boolean | false | Add this project to go.work file |
-
-### Go Blueprint Specific Options
-
-When `type` is set to "go-blueprint", additional options become available:
-
-| Option | Type | Default | Description |
-| --------- | ------ | ------- | -------------------------------------------------------------------------------- |
-| framework | string | "gin" | Web framework (chi, gin, fiber, gorilla/mux, httprouter, standard-library, echo) |
-| driver | string | "none" | Database driver (mysql, postgres, sqlite, mongo, redis, scylla, none) |
-| git | string | "skip" | Git handling (commit, stage, skip) |
-| feature | array | [] | Advanced features (react, htmx, githubaction, websocket, tailwind, docker) |
-
-## Examples
-
-### Interactive Mode (Recommended)
-
-```bash
-npx create-nx-workspace my-go-workspace --preset=@naxodev/gonx
-```
-
-This will prompt you to select the template type and configure all options interactively.
-
-### Create Binary Application
-
-```bash
-npx create-nx-workspace go-app --preset=@naxodev/gonx --type=binary
-```
-
-### Create Library
-
-```bash
-npx create-nx-workspace go-lib --preset=@naxodev/gonx --type=library
-```
-
-### Create Go Blueprint Application
-
-```bash
-npx create-nx-workspace go-api --preset=@naxodev/gonx --type=go-blueprint --framework=gin --driver=postgres --git=commit
-```
-
-### Go Blueprint with Advanced Features
-
-```bash
-npx create-nx-workspace go-app --preset=@naxodev/gonx \
- --type=go-blueprint \
- --framework=fiber \
- --driver=mysql \
- --git=stage \
- --feature=docker,githubaction
-```
-
-### With Go Workspace
-
-```bash
-npx create-nx-workspace go-workspace --preset=@naxodev/gonx \
- --type=go-blueprint \
- --framework=echo \
- --driver=sqlite \
- --addGoDotWork=true
-```
-
-## Template Types
-
-### Binary
-
-- Creates a standard Go application using gonx's application generator
-- Simple `main.go` with basic structure
-- Ready for immediate development with `nx build`, `nx serve`, etc.
-
-### Library
-
-- Creates a Go library using gonx's library generator
-- Includes example library code and tests
-- Configured for sharing and reuse
-
-### Go Blueprint
-
-- Uses [Go Blueprint](https://github.com/Melkeydev/go-blueprint) for advanced scaffolding
-- Provides multiple web frameworks and database integrations
-- Includes optional features like Docker, GitHub Actions, WebSockets, etc.
-- Go Blueprint binary is included with the package
-
-## Project Structure
-
-### Binary/Library Output
-
-```
-my-go-project/
-├── main.go (or library code)
-├── go.mod
-├── go.sum
-└── nx.json
-```
-
-### Go Blueprint Output
-
-The structure varies based on selected framework and features, but typically includes:
-
-```
-my-go-project/
-├── main.go
-├── go.mod
-├── go.sum
-├── handlers/
-├── models/
-├── database/
-├── static/
-├── Dockerfile (if docker feature selected)
-└── ... (additional files based on features)
-```
-
-## Notes
-
-- Creates a new Nx workspace with gonx pre-configured
-- Sets up the workspace with Go support and inferred tasks
-- Ready to use immediately for Go development
-- Go Blueprint binary is bundled with the package
-- Creates go.work file only when explicitly requested via the `addGoDotWork` option
-- All template types support the full gonx toolchain (build, test, lint, etc.)
-
-## Integration with Nx
-
-After workspace creation, all standard Nx commands work immediately:
-
-```bash
-# Build your project
-nx build
-
-# Run your application
-nx serve
-
-# Run tests
-nx test
-
-# Lint code
-nx lint
-
-# View project graph
-nx graph
-```
diff --git a/docs/gonx-docs/src/content/docs/getting-started/installation.md b/docs/gonx-docs/src/content/docs/getting-started/installation.md
new file mode 100644
index 000000000..a44d4293e
--- /dev/null
+++ b/docs/gonx-docs/src/content/docs/getting-started/installation.md
@@ -0,0 +1,90 @@
+---
+title: Install GoNx
+description: How to install and configure @naxodev/gonx in your workspace.
+---
+
+import { Steps } from '@astrojs/starlight/components';
+
+How to install `@naxodev/gonx` in an existing Nx workspace and register the
+inference plugin.
+
+## Before you start
+
+- An **Nx 23.x** workspace (or later)
+- **Node.js 20+**
+- **Go** — a [stable release](https://go.dev/dl/) (1.18+ for multi-module
+ workspaces)
+
+Don't have a workspace yet? Create one with the gonx preset and skip to step 3:
+
+```bash
+npx create-nx-workspace my-org --preset=@naxodev/gonx
+```
+
+## Steps
+
+
+1. **Install the package**
+
+```bash
+npm install @naxodev/gonx --save-dev
+```
+
+Or with Nx's built-in installer, which also runs any migrations:
+
+```bash
+npx nx add @naxodev/gonx
+```
+
+2. **Register the inference plugin in `nx.json`**
+
+ Add `@naxodev/gonx` to the `plugins` array:
+
+ ```json
+ {
+ "plugins": ["@naxodev/gonx"]
+ }
+ ```
+
+ The plugin infers Nx projects from every `go.mod` matched by `**/go.mod`.
+ No per-project `project.json` is needed.
+
+3. **Verify the plugin is loaded**
+
+ ```bash
+ npx nx show projects
+ ```
+
+ Every directory containing a `go.mod` should appear as an Nx project. If you
+ used the preset, your starter Go project will be listed.
+
+
+## Configuration
+
+To customize inferred target names or disable dependency detection, use the
+object form with `options`:
+
+```json
+{
+ "plugins": [
+ {
+ "plugin": "@naxodev/gonx",
+ "options": {
+ "buildTargetName": "build",
+ "testTargetName": "test",
+ "skipGoDependencyCheck": false
+ }
+ }
+ ]
+}
+```
+
+See the [plugin options reference](/guides/generators/options) for every
+available option.
+
+## Next steps
+
+- [Quick start](/getting-started/quick-start) — create, run, test, and build a Go app
+- [Create your first Go project](/tutorials/first-go-project) — a full tutorial walkthrough
+- [Application generator](/guides/generators/application) — scaffold a Go application
+- [Migrate to gonx 3.0.0](/community/migration) — coming from nx-go
diff --git a/docs/gonx-docs/src/content/docs/getting-started/introduction.md b/docs/gonx-docs/src/content/docs/getting-started/introduction.md
new file mode 100644
index 000000000..1da3f761f
--- /dev/null
+++ b/docs/gonx-docs/src/content/docs/getting-started/introduction.md
@@ -0,0 +1,37 @@
+---
+title: Introduction
+description: What is GoNx and what can it do for you?
+---
+
+GoNx is an [Nx](https://nx.dev/) plugin for [Go](https://go.dev/) development. It
+brings the benefits of Nx — caching, affected-task detection, project graph
+visualization, and generators — to Go projects without requiring hand-written
+`project.json` targets.
+
+## What gonx does
+
+gonx infers build, serve, test, lint, tidy, and generate targets automatically
+from every `go.mod` in your workspace. It builds the Nx project graph by
+parsing Go source files with [tree-sitter](https://tree-sitter.github.io/) to
+extract import statements and resolve them to Nx projects — no Go toolchain
+required for graph computation. It also ships generators for scaffolding
+applications, libraries, and [Go Blueprint](https://github.com/melkeydev/go-blueprint)
+projects with web frameworks and database drivers.
+
+## Who it's for
+
+gonx is for teams and individuals who already use Nx (or want to) and have Go
+projects in their workspace. It is a fork of
+[@nx-go/nx-go](https://github.com/nx-go/nx-go), modernized for Nx 23 with
+inferred tasks and a tree-sitter-based project graph. If you are migrating from
+nx-go, see the [migration guide](/community/migration).
+
+## Where to go next
+
+- New to gonx? Start with the [quick start](/getting-started/quick-start).
+- Adding gonx to an existing workspace? See
+ [install gonx](/getting-started/installation).
+- Want a step-by-step walkthrough? Read
+ [create your first Go project](/tutorials/first-go-project).
+- Curious how the project graph works? See
+ [how static analysis works](/understanding/static-analysis).
diff --git a/docs/gonx-docs/src/content/docs/getting-started/quick-start.md b/docs/gonx-docs/src/content/docs/getting-started/quick-start.md
new file mode 100644
index 000000000..2163f73a5
--- /dev/null
+++ b/docs/gonx-docs/src/content/docs/getting-started/quick-start.md
@@ -0,0 +1,98 @@
+---
+title: Quick start
+description: Get up and running with gonx in under a minute.
+---
+
+import { Steps } from '@astrojs/starlight/components';
+
+Create a Go application with Nx, then run, test, and build it using targets that
+gonx infers from `go.mod`.
+
+:::note
+gonx is a fork of [@nx-go/nx-go](https://github.com/nx-go/nx-go), modernized for
+Nx 23 with inferred tasks and a tree-sitter-based project graph.
+:::
+
+## Before you start
+
+- **Node.js 20+** and an Nx 23.x workspace
+- **Go** — a [stable release](https://go.dev/dl/) (1.18+ for multi-module
+ workspaces)
+
+gonx 3.x targets Nx 23.x:
+
+| Nx version | gonx version |
+| ---------- | ------------ |
+| 23.x | 3.x |
+
+## Steps
+
+
+1. **Create a workspace with the gonx preset**
+ ```bash
+ npx create-nx-workspace go-workspace --preset=@naxodev/gonx
+ ```
+ This scaffolds an Nx workspace with gonx registered and a starter Go project.
+ If you already have a workspace, install gonx into it instead:
+ ```bash
+ npx nx add @naxodev/gonx
+ ```
+
+2. **Create a Go application**
+
+ ```bash
+ cd go-workspace
+ npx nx g @naxodev/gonx:application my-go-app
+ ```
+
+ The generator creates a Go project with a `package main` entry point. gonx
+ detects the `go.mod` and infers `build`, `serve`, `test`, `lint`, `tidy`, and
+ `generate` targets. Pass `--template` to choose `standard`, `cli`, or `tui`.
+ See the [application generator guide](/guides/generators/application) for all
+ options.
+
+3. **Run the application**
+
+ ```bash
+ npx nx serve my-go-app
+ ```
+
+ The `serve` target runs `go run` from the project root. See the
+ [serve executor guide](/guides/executors/serve).
+
+4. **Test the project**
+
+ ```bash
+ npx nx test my-go-app
+ ```
+
+ The `test` target runs `go test`. See the
+ [test executor guide](/guides/executors/test).
+
+5. **Build the project**
+ ```bash
+ npx nx build my-go-app
+ ```
+ The `build` target compiles an executable. See the
+ [build executor guide](/guides/executors/build).
+
+
+## Verify
+
+List the projects Nx detected and the targets inferred for your application:
+
+```bash
+npx nx show projects
+npx nx show project my-go-app
+```
+
+`nx show project` lists the `build`, `serve`, `test`, `lint`, `tidy`, and
+`generate` targets with no `project.json` file. Run `npx nx build my-go-app` a
+second time to confirm caching — the second run is served from the Nx cache.
+
+## Next steps
+
+- [Create your first Go project](/tutorials/first-go-project) — a full walkthrough with explanations
+- [Install GoNx](/getting-started/installation) — add gonx to an existing workspace
+- [Plugin options](/guides/generators/options) — customize target names and tags
+- [Migrate to gonx 3.0.0](/community/migration) — coming from nx-go
diff --git a/docs/gonx-docs/src/content/docs/guides/executors/build.md b/docs/gonx-docs/src/content/docs/guides/executors/build.md
new file mode 100644
index 000000000..a70160f1a
--- /dev/null
+++ b/docs/gonx-docs/src/content/docs/guides/executors/build.md
@@ -0,0 +1,50 @@
+---
+title: Build executor
+description: Compiles a Go program into an executable using the go build command.
+---
+
+The build executor compiles a Go program into an executable using `go build`.
+
+## Usage
+
+```bash
+nx build my-go-app
+```
+
+## Options
+
+| Option | Type | Default | Description |
+| ---------- | ------------------- | ------- | ---------------------------------------------------------------------------- |
+| main | string | - | Relative path from the project root to the main.go file defining the binary. |
+| compiler | go \| tinygo \| gow | go | The Go compiler to use. |
+| outputPath | string | - | The output path of the resulting executable. |
+| buildMode | string | - | The build mode to use. |
+| env | object | - | Environment variables to set when running the executor. |
+| flags | string[] | - | Flags to pass to the go compiler. |
+
+When `main` is set, the build runs from the directory containing that main.go file. When omitted, the build targets `./...` (all packages in the project tree).
+
+## Inferred target
+
+Inferred for projects containing a `main` package (applications). The plugin generates:
+
+```json
+{
+ "executor": "@naxodev/gonx:build",
+ "cache": true,
+ "dependsOn": ["generate"],
+ "inputs": ["{projectRoot}/go.mod", "{projectRoot}/go.sum", "{projectRoot}/**/*.{go}"],
+ "options": {
+ "outputPath": "dist/{projectRoot}/"
+ },
+ "outputs": ["{options.outputPath}"]
+}
+```
+
+The default `outputPath` resolves to `dist//`. Override it via the `outputPath` option.
+
+## Next steps
+
+- [Serve executor](/guides/executors/serve)
+- [Test executor](/guides/executors/test)
+- [Plugin options](/guides/generators/options)
diff --git a/docs/gonx-docs/src/content/docs/guides/executors/generate.md b/docs/gonx-docs/src/content/docs/guides/executors/generate.md
new file mode 100644
index 000000000..f8264e256
--- /dev/null
+++ b/docs/gonx-docs/src/content/docs/guides/executors/generate.md
@@ -0,0 +1,42 @@
+---
+title: Generate executor
+description: Runs code generation using the go generate command.
+---
+
+The generate executor runs code generation using `go generate ./...`, processing all `//go:generate` directives in the project tree.
+
+## Usage
+
+```bash
+nx run my-go-project:generate
+```
+
+Use `nx run :generate` instead of `nx generate ` to avoid conflicts with Nx's native generator command.
+
+## Options
+
+| Option | Type | Default | Description |
+| ------ | -------- | ------- | ------------------------------------------------------- |
+| env | object | - | Environment variables to set when running the executor. |
+| flags | string[] | - | Flags to pass to the go generate command. |
+
+## Inferred target
+
+Inferred for all Go projects (applications and libraries):
+
+```json
+{
+ "executor": "@naxodev/gonx:generate",
+ "cache": true,
+ "dependsOn": ["^generate"],
+ "inputs": ["{projectRoot}/go.mod", "{projectRoot}/go.sum", "{projectRoot}/**/*.{go}"]
+}
+```
+
+The `^generate` dependency means generate targets run after upstream project generate targets complete.
+
+## Next steps
+
+- [Build executor](/guides/executors/build)
+- [Test executor](/guides/executors/test)
+- [Plugin options](/guides/generators/options)
diff --git a/docs/gonx-docs/src/content/docs/guides/executors/lint.md b/docs/gonx-docs/src/content/docs/guides/executors/lint.md
new file mode 100644
index 000000000..f59974c14
--- /dev/null
+++ b/docs/gonx-docs/src/content/docs/guides/executors/lint.md
@@ -0,0 +1,39 @@
+---
+title: Lint executor
+description: Formats and lints a Go project.
+---
+
+The lint executor formats and lints a Go project. By default it runs `go fmt ./...`.
+
+## Usage
+
+```bash
+nx lint my-go-project
+```
+
+## Options
+
+| Option | Type | Default | Description |
+| ------ | -------- | ------- | ------------------------------------------- |
+| linter | string | go fmt | The command to execute instead of `go fmt`. |
+| args | string[] | - | Extra args passed to the linter. |
+
+When `linter` is set, the executor runs that command with `args` and `./...` appended, bypassing `go fmt`.
+
+## Inferred target
+
+Inferred for all Go projects (applications and libraries):
+
+```json
+{
+ "executor": "@naxodev/gonx:lint",
+ "cache": true,
+ "inputs": ["{projectRoot}/go.mod", "{projectRoot}/go.sum", "{projectRoot}/**/*.{go}"]
+}
+```
+
+## Next steps
+
+- [Test executor](/guides/executors/test)
+- [Tidy executor](/guides/executors/tidy)
+- [Plugin options](/guides/generators/options)
diff --git a/docs/gonx-docs/src/content/docs/guides/executors/nx-release-publish.md b/docs/gonx-docs/src/content/docs/guides/executors/nx-release-publish.md
new file mode 100644
index 000000000..ad8445d14
--- /dev/null
+++ b/docs/gonx-docs/src/content/docs/guides/executors/nx-release-publish.md
@@ -0,0 +1,57 @@
+---
+title: nx-release-publish executor
+description: Publishes a Go module to the Go proxy as part of the Nx release process.
+---
+
+The nx-release-publish executor publishes a Go module to the Go proxy (proxy.golang.org) by running `GOPROXY=proxy.golang.org go list -m @`. The version is resolved from the latest git tag matching the release tag pattern configured in `nx.json`.
+
+The manifest key in `executors.json` is `release-publish`. The inferred target name is `nx-release-publish`.
+
+## Usage
+
+```bash
+nx nx-release-publish my-go-lib
+```
+
+Or through the Nx release pipeline:
+
+```bash
+nx release --publish
+```
+
+## Options
+
+| Option | Type | Default | Description |
+| ---------- | ------- | ------------ | ---------------------------------------------------------- |
+| moduleRoot | string | project root | Path to the directory containing the go.mod file. |
+| dryRun | boolean | false | When true, print the publish command without executing it. |
+
+The `NX_DRY_RUN` environment variable also triggers a dry run when set to `true`.
+
+## Inferred target
+
+Inferred for all Go projects (applications and libraries):
+
+```json
+{
+ "executor": "@naxodev/gonx:release-publish",
+ "options": {
+ "moduleRoot": "{projectRoot}"
+ },
+ "configurations": {
+ "development": {
+ "dryRun": true
+ }
+ }
+}
+```
+
+The `development` configuration sets `dryRun: true`, allowing test runs via `--configuration=development`.
+
+The default release tag pattern is `v{version}`. Override it in `nx.json` under `release.releaseTag.pattern`, which supports `{projectName}` and `{version}` placeholders.
+
+## Next steps
+
+- [Build executor](/guides/executors/build)
+- [Plugin options](/guides/generators/options)
+- [Quick start](/getting-started/quick-start)
diff --git a/docs/gonx-docs/src/content/docs/guides/executors/serve.md b/docs/gonx-docs/src/content/docs/guides/executors/serve.md
new file mode 100644
index 000000000..d47668ad2
--- /dev/null
+++ b/docs/gonx-docs/src/content/docs/guides/executors/serve.md
@@ -0,0 +1,40 @@
+---
+title: Serve executor
+description: Runs a Go application using the go run command.
+---
+
+The serve executor runs a Go application using `go run`.
+
+## Usage
+
+```bash
+nx serve my-go-app
+```
+
+## Options
+
+| Option | Type | Default | Description |
+| ------ | ------------------- | ------- | ---------------------------------------------------------------------------- |
+| main | string | - | Relative path from the project root to the main.go file defining the binary. |
+| cmd | go \| tinygo \| gow | go | The binary to use for running the application. |
+| args | string[] | - | Extra args passed to the run command. |
+| env | object | - | Environment variables to set when running the application. |
+
+When `main` is set, the serve runs from the directory containing that main.go file. When omitted, the serve targets `./...`.
+
+## Inferred target
+
+Inferred for projects containing a `main` package (applications). The target is continuous and not cached:
+
+```json
+{
+ "executor": "@naxodev/gonx:serve",
+ "continuous": true,
+ "options": {}
+}
+```
+
+## Next steps
+
+- [Build executor](/guides/executors/build)
+- [Plugin options](/guides/generators/options)
diff --git a/docs/gonx-docs/src/content/docs/guides/executors/test.md b/docs/gonx-docs/src/content/docs/guides/executors/test.md
new file mode 100644
index 000000000..29c452025
--- /dev/null
+++ b/docs/gonx-docs/src/content/docs/guides/executors/test.md
@@ -0,0 +1,45 @@
+---
+title: Test executor
+description: Runs tests for a Go project using the go test command.
+---
+
+The test executor runs Go tests using `go test ./...`.
+
+## Usage
+
+```bash
+nx test my-go-project
+```
+
+## Options
+
+| Option | Type | Default | Description |
+| ------------ | ------- | ------- | --------------------------------------------------------------------------- |
+| cover | boolean | false | Enable coverage analysis. |
+| coverProfile | string | - | Write a coverage profile to the file after all tests have passed. |
+| race | boolean | false | Enable the race detector. |
+| run | string | - | Run only tests matching this regular expression. |
+| verbose | boolean | false | Enable verbose test output. |
+| count | number | - | Run each test N times. |
+| timeout | string | 10m | Panic if a test binary runs longer than this duration. Set to 0 to disable. |
+
+## Inferred target
+
+Inferred for all Go projects (applications and libraries):
+
+```json
+{
+ "executor": "@naxodev/gonx:test",
+ "cache": true,
+ "dependsOn": ["generate", "^build"],
+ "inputs": ["{projectRoot}/go.mod", "{projectRoot}/go.sum", "{projectRoot}/**/*.{go}"]
+}
+```
+
+The `^build` dependency means test targets run after upstream project build targets complete.
+
+## Next steps
+
+- [Build executor](/guides/executors/build)
+- [Lint executor](/guides/executors/lint)
+- [Plugin options](/guides/generators/options)
diff --git a/docs/gonx-docs/src/content/docs/guides/executors/tidy.md b/docs/gonx-docs/src/content/docs/guides/executors/tidy.md
new file mode 100644
index 000000000..29d0b1f9a
--- /dev/null
+++ b/docs/gonx-docs/src/content/docs/guides/executors/tidy.md
@@ -0,0 +1,35 @@
+---
+title: Tidy executor
+description: Runs go mod tidy to sync go.mod with the project source code.
+---
+
+The tidy executor runs `go mod tidy` to ensure the go.mod file matches the project source code.
+
+## Usage
+
+```bash
+nx tidy my-go-project
+```
+
+## Options
+
+| Option | Type | Default | Description |
+| ------ | -------- | ------- | ----------------------------------- |
+| args | string[] | - | Extra args passed to `go mod tidy`. |
+
+## Inferred target
+
+Inferred for all Go projects (applications and libraries):
+
+```json
+{
+ "executor": "@naxodev/gonx:tidy",
+ "cache": true,
+ "inputs": ["{projectRoot}/go.mod", "{projectRoot}/go.sum", "{projectRoot}/**/*.{go}"]
+}
+```
+
+## Next steps
+
+- [Lint executor](/guides/executors/lint)
+- [Plugin options](/guides/generators/options)
diff --git a/docs/gonx-docs/src/content/docs/guides/generators/application.md b/docs/gonx-docs/src/content/docs/guides/generators/application.md
new file mode 100644
index 000000000..0ccf57b57
--- /dev/null
+++ b/docs/gonx-docs/src/content/docs/guides/generators/application.md
@@ -0,0 +1,34 @@
+---
+title: Application generator
+description: Generates a Go application and registers it as an Nx project through the gonx inference plugin.
+---
+
+Generates a Go application under the given directory and registers it as an Nx project through the gonx inference plugin. Aliased as `app`.
+
+## Usage
+
+```bash
+nx g @naxodev/gonx:application
+```
+
+## Options
+
+| Option | Type | Default | Description |
+| ---------- | ---------------------------- | ---------- | --------------------------------------------------------------------------- |
+| directory | string | _required_ | Directory of the new application. Taken from the first positional argument. |
+| name | string | - | Name of the application. Must match `^[a-zA-Z][^:]*$`. |
+| template | `standard` \| `cli` \| `tui` | `standard` | Application template to generate. |
+| tags | string | - | Tags to add to the application (used for linting). |
+| skipFormat | boolean | `false` | Skip formatting files. |
+
+## Notes
+
+- Runs the init generator first to register the inference plugin in `nx.json`.
+- Creates a `go.mod` for the project unless the template already includes one. Adds the project to `go.work` when a Go workspace is present.
+- Inferred targets for applications: `build`, `serve`, `test`, `lint`, `tidy`, `generate`, `nx-release-publish`. Application detection requires a `main.go` containing `package main` and `func main(`, or a `cmd/` directory.
+
+## Next steps
+
+- [Library generator](/guides/generators/library)
+- [Build executor](/guides/executors/build)
+- [Serve executor](/guides/executors/serve)
diff --git a/docs/gonx-docs/src/content/docs/guides/generators/go-blueprint.md b/docs/gonx-docs/src/content/docs/guides/generators/go-blueprint.md
new file mode 100644
index 000000000..f6d9d7273
--- /dev/null
+++ b/docs/gonx-docs/src/content/docs/guides/generators/go-blueprint.md
@@ -0,0 +1,40 @@
+---
+title: Go Blueprint generator
+description: Generates a Go application by wrapping the @melkeydev/go-blueprint CLI.
+---
+
+Generates a Go application by wrapping the `@melkeydev/go-blueprint` CLI, which is bundled with this package. Scaffolds a project from a selected web framework, database driver, and optional advanced features.
+
+## Usage
+
+```bash
+nx g @naxodev/gonx:go-blueprint
+```
+
+## Options
+
+| Option | Type | Default | Description |
+| ------------ | ------------------------------------------------------------------------------------------ | ---------- | -------------------------------------------------------------------------------------- |
+| directory | string | _required_ | Directory of the new application. Taken from the first positional argument. |
+| name | string | - | Name of the application. Must match `^[a-zA-Z][^:]*$`. |
+| tags | string | - | Tags to add to the project (used for linting). |
+| skipFormat | boolean | `false` | Skip formatting files. |
+| addGoDotWork | boolean | `false` | Add this project to `go.work`. |
+| framework | `chi` \| `gin` \| `fiber` \| `gorilla/mux` \| `httprouter` \| `standard-library` \| `echo` | _required_ | Web framework. |
+| driver | `mysql` \| `postgres` \| `sqlite` \| `mongo` \| `redis` \| `scylla` \| `none` | _required_ | Database driver. |
+| git | `commit` \| `stage` \| `skip` | _required_ | Git handling. |
+| feature | array | - | Advanced features: `react`, `htmx`, `githubaction`, `websocket`, `tailwind`, `docker`. |
+
+## Notes
+
+- The `@melkeydev/go-blueprint` binary is resolved from the bundled npm dependency; no separate installation is required.
+- Runs the init generator first to register the inference plugin. Adds the project to `go.work` when `addGoDotWork` is set and a Go workspace is supported.
+- Removes `.air.toml`, `README.md`, and `Makefile` from the generated output.
+- The `react` feature embeds frontend code inside the Go project directory, which Nx's project graph does not detect as a separate project.
+- Inferred targets for the resulting application: `build`, `serve`, `test`, `lint`, `tidy`, `generate`, `nx-release-publish`.
+
+## Next steps
+
+- [Application generator](/guides/generators/application)
+- [Build executor](/guides/executors/build)
+- [Serve executor](/guides/executors/serve)
diff --git a/docs/gonx-docs/src/content/docs/guides/generators/init.md b/docs/gonx-docs/src/content/docs/guides/generators/init.md
new file mode 100644
index 000000000..52b9f0699
--- /dev/null
+++ b/docs/gonx-docs/src/content/docs/guides/generators/init.md
@@ -0,0 +1,30 @@
+---
+title: Init generator
+description: Registers the gonx inference plugin in an Nx workspace and optionally creates a go.work file.
+---
+
+Registers the gonx inference plugin in `nx.json` and optionally creates a `go.work` file. Hidden from `nx list` and invoked automatically by the other generators.
+
+## Usage
+
+```bash
+nx g @naxodev/gonx:init
+```
+
+## Options
+
+| Option | Type | Default | Description |
+| ------------ | ------- | ------- | ------------------------------------------------------------ |
+| skipFormat | boolean | `false` | Skip formatting files. |
+| addGoDotWork | boolean | `false` | Create a `go.work` file and add Go config to shared globals. |
+
+## Notes
+
+- `go.work` creation requires a locally installed Go toolchain that supports Go workspaces.
+- Invoked by the application, library, and go-blueprint generators (and indirectly by the preset generator) with `skipFormat: true`.
+
+## Next steps
+
+- [Application generator](/guides/generators/application)
+- [Library generator](/guides/generators/library)
+- [Plugin options](/guides/generators/options)
diff --git a/docs/gonx-docs/src/content/docs/guides/generators/library.md b/docs/gonx-docs/src/content/docs/guides/generators/library.md
new file mode 100644
index 000000000..585092043
--- /dev/null
+++ b/docs/gonx-docs/src/content/docs/guides/generators/library.md
@@ -0,0 +1,33 @@
+---
+title: Library generator
+description: Generates a Go library and registers it as an Nx project through the gonx inference plugin.
+---
+
+Generates a Go library under the given directory and registers it as an Nx project through the gonx inference plugin. Aliased as `lib`.
+
+## Usage
+
+```bash
+nx g @naxodev/gonx:library
+```
+
+## Options
+
+| Option | Type | Default | Description |
+| ---------- | ------- | ---------- | ----------------------------------------------------------------------- |
+| directory | string | _required_ | Directory of the new library. Taken from the first positional argument. |
+| name | string | - | Name of the library. Must match `^[a-zA-Z][^:]*$`. |
+| tags | string | - | Tags to add to the library (used for linting). |
+| skipFormat | boolean | `false` | Skip formatting files. |
+
+## Notes
+
+- Runs the init generator first to register the inference plugin in `nx.json`.
+- Always creates a `go.mod` for the project. Adds the project to `go.work` when a Go workspace is present.
+- Inferred targets for libraries: `test`, `lint`, `tidy`, `generate`, `nx-release-publish`. Libraries do not infer `build` or `serve`.
+
+## Next steps
+
+- [Application generator](/guides/generators/application)
+- [Test executor](/guides/executors/test)
+- [Lint executor](/guides/executors/lint)
diff --git a/docs/gonx-docs/src/content/docs/guides/generators/options.md b/docs/gonx-docs/src/content/docs/guides/generators/options.md
new file mode 100644
index 000000000..78e80a104
--- /dev/null
+++ b/docs/gonx-docs/src/content/docs/guides/generators/options.md
@@ -0,0 +1,57 @@
+---
+title: Plugin options
+description: GoPluginOptions reference for the @naxodev/gonx plugin registration in nx.json.
+---
+
+Reference for the `GoPluginOptions` accepted by the `@naxodev/gonx` plugin registration in `nx.json`. The plugin infers Nx projects from every `go.mod` matched by `**/go.mod`.
+
+## Usage
+
+String form (all defaults apply):
+
+```json
+{
+ "plugins": ["@naxodev/gonx"]
+}
+```
+
+Object form:
+
+```json
+{
+ "plugins": [
+ {
+ "plugin": "@naxodev/gonx",
+ "options": {
+ "buildTargetName": "build",
+ "skipGoDependencyCheck": true
+ }
+ }
+ ]
+}
+```
+
+## Options
+
+| Option | Type | Default | Description |
+| ------------------------ | ------- | -------------------- | ------------------------------------------------------------------- |
+| buildTargetName | string | `build` | Name of the inferred build target. Inferred only for applications. |
+| testTargetName | string | `test` | Name of the inferred test target. |
+| runTargetName | string | `serve` | Name of the inferred run target. Inferred only for applications. |
+| tidyTargetName | string | `tidy` | Name of the inferred tidy target. |
+| lintTargetName | string | `lint` | Name of the inferred lint target. |
+| generateTargetName | string | `generate` | Name of the inferred generate target. |
+| releasePublishTargetName | string | `nx-release-publish` | Name of the inferred release publish target. |
+| tagName | string | - | Tag applied to every inferred Go project. |
+| skipGoDependencyCheck | boolean | `false` | Disables Go project dependency detection in the Nx workspace graph. |
+
+## Notes
+
+- Applications are projects with a `main.go` containing `package main` and `func main(`, or a `cmd/` directory. All other Go projects are treated as libraries.
+- `buildTargetName` and `runTargetName` only affect applications; libraries never infer build or run targets regardless of these options.
+
+## Next steps
+
+- [Application generator](/guides/generators/application)
+- [Library generator](/guides/generators/library)
+- [Init generator](/guides/generators/init)
diff --git a/docs/gonx-docs/src/content/docs/guides/generators/preset.md b/docs/gonx-docs/src/content/docs/guides/generators/preset.md
new file mode 100644
index 000000000..d301bf084
--- /dev/null
+++ b/docs/gonx-docs/src/content/docs/guides/generators/preset.md
@@ -0,0 +1,45 @@
+---
+title: Preset generator
+description: Preset used by create-nx-workspace to scaffold a new Nx workspace with gonx pre-configured.
+---
+
+Preset used by `create-nx-workspace` to scaffold a new Nx workspace with gonx pre-configured. Delegates to the application, library, or go-blueprint generator based on the selected `type`.
+
+## Usage
+
+```bash
+npx create-nx-workspace --preset=@naxodev/gonx
+```
+
+## Options
+
+| Option | Type | Default | Description |
+| ------------ | --------------------------------------- | ---------- | ----------------------------------------------------------------------- |
+| type | `binary` \| `library` \| `go-blueprint` | `binary` | Template type to generate. Required. |
+| directory | string | _required_ | Directory of the new project. Taken from the first positional argument. |
+| name | string | - | Name of the project. Must match `^[a-zA-Z][^:]*$`. |
+| tags | string | - | Tags to add to the project (used for linting). |
+| skipFormat | boolean | `false` | Skip formatting files. |
+| addGoDotWork | boolean | `false` | Add a `go.work` file to the project. |
+
+### go-blueprint options
+
+When `type` is `go-blueprint`, the following options are also required:
+
+| Option | Type | Default | Description |
+| --------- | ------------------------------------------------------------------------------------------ | ---------- | -------------------------------------------------------------------------------------- |
+| framework | `chi` \| `gin` \| `fiber` \| `gorilla/mux` \| `httprouter` \| `standard-library` \| `echo` | _required_ | Web framework. |
+| driver | `mysql` \| `postgres` \| `sqlite` \| `mongo` \| `redis` \| `scylla` \| `none` | _required_ | Database driver. |
+| git | `commit` \| `stage` \| `skip` | _required_ | Git handling. |
+| feature | array | - | Advanced features: `react`, `htmx`, `githubaction`, `websocket`, `tailwind`, `docker`. |
+
+## Notes
+
+- `type=binary` delegates to the application generator; `type=library` delegates to the library generator; `type=go-blueprint` delegates to the go-blueprint generator.
+- When invoked programmatically without go-blueprint values, the preset applies `framework=gin`, `driver=none`, `git=skip`, `feature=[]`.
+
+## Next steps
+
+- [Application generator](/guides/generators/application)
+- [Library generator](/guides/generators/library)
+- [Go Blueprint generator](/guides/generators/go-blueprint)
diff --git a/docs/gonx-docs/src/content/docs/index.mdx b/docs/gonx-docs/src/content/docs/index.mdx
index 3b7cc4168..7ebcf587c 100644
--- a/docs/gonx-docs/src/content/docs/index.mdx
+++ b/docs/gonx-docs/src/content/docs/index.mdx
@@ -1,18 +1,14 @@
---
title: GoNx documentation
-description: Nx plugin for Go Development
+description: Nx plugin for Go development
template: splash
hero:
- tagline: A Nx plugin for Go development
+ tagline: An Nx plugin for Go development
---
import { Card, CardGrid } from '@astrojs/starlight/components';
-
- Join our [Discord Server](https://discord.gg/zjDCGpKP2S) to chat with the
- community and get support.
-
- A modern Nx plugin for [Go/Golang](/quick-start) development with full Nx integration,
- inferred tasks, and official Go command support.
+ An Nx plugin for [Go](https://go.dev/) development. gonx infers build, serve,
+ test, lint, tidy, and generate targets from each go.mod, builds
+ the project graph from Go imports, and ships generators for applications, libraries,
+ and Go Blueprint projects. Available on [npm](https://www.npmjs.com/package/@naxodev/gonx).
-
- GoNx is open source and welcomes contributions. Check out our [GitHub
- repository](https://github.com/naxodev/oss/tree/main/packages/gonx).
+
+ gonx is MIT licensed and developed on
+ [GitHub](https://github.com/naxodev/oss/tree/main/packages/gonx). Report
+ bugs and request features in the [issue
+ tracker](https://github.com/naxodev/oss/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc).
+
+
+ Join the [Discord server](https://discord.gg/zjDCGpKP2S) to ask questions
+ and get help.
---
-## ✨ Key Features
+## Key features
- 🚀
-
Modern Nx Integration
+
Inferred tasks
- Built for the latest Nx features with full support for inferred tasks.
+ gonx detects each go.mod and infers build, serve, test, lint,
+ tidy, and generate targets automatically — no hand-written project.json
+ files.
{' '}
+{' '}
+
- 🐹
-
Advanced Go boilerplate generators
+
Project graph from static analysis
- Provides a comprehensive list of generators to reduce boilerplate time,
- including a Go Blueprint integration.
+ A tree-sitter parser reads Go imports and go.mod files to build
+ Nx project dependencies.
{' '}
-
- 📦
-
Monorepo Ready
-
- Designed for large-scale monorepo development.
-
-
+
+
Generators
+
+ Scaffold applications, libraries, and Go Blueprint projects with web
+ frameworks and database drivers.
+
+
---
-
Ready to Get Started?
-
- Choose your path and start building amazing projects today
-
diff --git a/docs/gonx-docs/src/content/docs/migration.md b/docs/gonx-docs/src/content/docs/migration.md
deleted file mode 100644
index eac3bc477..000000000
--- a/docs/gonx-docs/src/content/docs/migration.md
+++ /dev/null
@@ -1,199 +0,0 @@
----
-title: Migration from nx-go
-description: Guide for migrating from the original nx-go plugin to GoNx
----
-
-This guide helps you migrate from the original [@nx-go/nx-go](https://github.com/nx-go/nx-go) plugin to GoNx.
-
-:::caution
-Although GoNx works well as a drop-in replacement for nx-go in most cases, our philosophy and core implementation have changed since the first fork, which may cause some workflows designed for nx-go not to work with GoNx.
-:::
-
-## Overview of Changes
-
-GoNx is a modernized fork of nx-go with significant architectural changes:
-
-### Major Breaking Changes
-
-1. **Modern Nx-only**: Requires Nx 21.x or later
-2. **No project.json generation**: Uses inferred tasks instead
-3. **Changed command execution**: Runs from project root instead of workspace root
-4. **Removed go.work creation**: Now opt-in via configuration
-5. **Removed legacy generators**: `convert-to-one-module` is no longer available
-
-### New Features
-
-1. **Inferred tasks**: Automatic task detection and configuration
-2. **Cacheable operations**: All tasks are properly cached
-3. **CreateNodesV2**: Latest Nx project detection API
-4. **Version Actions**: Proper Go versioning with Nx Release
-5. **Publish executor**: Automated registry publishing
-
-## Migration Steps
-
-### Step 1: Prerequisites
-
-Before starting the migration:
-
-1. **Upgrade Nx**: Ensure you're on Nx 21.x or later
-2. **Update Go**: Use a stable Go version (1.21+ recommended)
-3. **Backup your workspace**: Create a backup before making changes
-4. **Review project structure**: Understand your current setup
-
-### Step 2: Remove nx-go Plugin
-
-Remove the original nx-go plugin:
-
-```bash
-npm uninstall @nx-go/nx-go
-# or
-pnpm remove @nx-go/nx-go
-# or
-yarn remove @nx-go/nx-go
-```
-
-### Step 3: Install GoNx
-
-Install the GoNx plugin:
-
-```bash
-npm install @naxodev/gonx
-# or
-pnpm add @naxodev/gonx
-# or
-yarn add @naxodev/gonx
-```
-
-### Step 4: Update Nx Configuration
-
-Update your `nx.json` to use GoNx:
-
-```json
-{
- "plugins": [
- {
- "plugin": "@naxodev/gonx",
- "options": {
- "addGoDotWork": false
- }
- }
- ]
-}
-```
-
-Remove any nx-go specific configuration.
-
-### Step 5: Handle project.json Files
-
-GoNx uses inferred tasks, so you can remove `project.json` files from your Go projects:
-
-:::caution
-Keep `project.json` files for non-Go projects or if you need custom task configuration.
-:::
-
-```bash
-# Remove project.json files from Go projects
-rm apps/my-go-app/project.json
-rm libs/my-go-lib/project.json
-```
-
-:::tip
-The inferred target configurations are available in the [executor's](/gonx/executors/generate) documentation in case modifications are needed.
-:::
-
-### Step 6: Update Scripts and CI
-
-Update any scripts or CI configurations that reference nx-go:
-
-#### Package.json Scripts
-
-```json
-{
- "scripts": {
- "build:go": "nx run-many --target=build --projects=tag:go",
- "test:go": "nx run-many --target=test --projects=tag:go"
- }
-}
-```
-
-#### CI Configuration
-
-Update your CI to use the new executors and ensure Go is available in the environment.
-
-## Common Migration Issues
-
----
-
-### Issue: Projects Named Changed
-
-**Problem**: GoNx changed how project names are inferred
-
-**Solution**:
-While nx-go uses the given name for the projects or the final segment of the path as the name, GoNx uses the entire path as the project name.
-
-Although this can make commands longer, it has two main benefits:
-
-- Removes the disambiguation name problem.
-- Aligns perfectly with the Go standard for multi-module repository tag creation.
-
-[Reference](https://go.dev/doc/modules/managing-source)
-
-### Issue: Tasks Not Found
-
-**Problem**: Nx doesn't recognize Go project tasks.
-
-**Solution**:
-
-1. Ensure `go.mod` files exist in your Go projects
-2. Clear Nx cache: `nx reset`
-3. Verify plugin configuration in `nx.json`
-
-### Issue: Project Graph Issues
-
-**Problem**: Project dependencies aren't detected correctly.
-
-**Solution**:
-
-1. Ensure Go imports are correctly structured
-2. Use proper module paths
-3. Clear cache and regenerate: `nx reset && nx graph`
-
-## Post-Migration Testing
-
-After migration, verify everything works:
-
-### 1. Project Detection
-
-```bash
-nx show projects
-```
-
-### 2. Task Execution
-
-```bash
-nx build my-go-app
-nx test my-go-lib
-nx lint my-go-app
-```
-
-### 3. Project Graph
-
-```bash
-nx graph
-```
-
-### 4. Caching
-
-```bash
-nx build my-go-app
-nx build my-go-app # Should use cache
-```
-
-## Getting Help
-
-If you encounter issues during migration:
-
-1. **Check documentation**: Review GoNx documentation thoroughly
-2. **Search issues**: Look for similar issues on GitHub
-3. **Join Discord**: Get real-time help on our [Discord server](https://discord.gg/zjDCGpKP2S)
-4. **Create issue**: Report bugs or request help on GitHub
diff --git a/docs/gonx-docs/src/content/docs/quick-start.md b/docs/gonx-docs/src/content/docs/quick-start.md
deleted file mode 100644
index 4ba920cd0..000000000
--- a/docs/gonx-docs/src/content/docs/quick-start.md
+++ /dev/null
@@ -1,245 +0,0 @@
----
-title: Quick Start
-description: Get up and running with OSS workspace plugins
----
-
-
-
-
-
-
-
GoNx
-
A modern Nx plugin for Go/Golang development
-
-
-GoNx - A very opinionated Nx plugin for Go/Golang
-
-The philosophy of gonx is to generate a non-invasive tooling to work with Go and Nx, heavily relying on inferred tasks and modern Nx features.
-
-:::note
-This project is a fork of [@nx-go/nx-go](https://github.com/nx-go/nx-go). Kudos to the original maintainers. We've built upon their excellent foundation.
-:::
-
-## Prerequisites
-
-Before getting started, ensure you have:
-
-- **Node.js** (version 18 or later)
-- **npm**, **pnpm**, or **yarn** package manager
-- **Nx CLI** (`npm install -g nx` or `npm install -g @nx/cli`)
-
-For GoNx specifically:
-
-- **Go** ([stable version](https://go.dev/dl/)) installed on your machine
-
-## Compatibility
-
-gonx is compatible with the following Nx versions:
-
-| Nx Version | gonx Version |
-| ---------- | ----------------- |
-| 21.x | >=^1.0.0 <=^2.0.0 |
-
-:::caution
-This plugin is only tested on [stable versions of Go](https://go.dev/dl/); older versions do not receive support. However, you can expect a fair degree of compatibility. Please note that multi-module Go workspaces require Go 1.18 or later.
-:::
-
-## Getting started
-
-### Option 1: Create a New Workspace with GoNx
-
-If you want to start a new workspace focused on Go development:
-
-```bash
-npx create-nx-workspace go-workspace --preset=@naxodev/gonx
-```
-
-This will create a new Nx workspace pre-configured with GoNx.
-
-### Option 2: Add to Existing Workspace
-
-If you have an existing Nx workspace and want to add our plugins:
-
-#### Add GoNx
-
-```bash
-nx add @naxodev/gonx
-```
-
-## Your First Project
-
-### Create a Go Application
-
-```bash
-nx g @naxodev/gonx:application my-go-app
-```
-
-### Create a Go Library
-
-```bash
-nx g @naxodev/gonx:library my-go-lib
-```
-
-## Common Commands
-
-Once you have projects set up, here are the most common commands you'll use:
-
-### Building Projects
-
-```bash
-# Build a Go application
-nx build my-go-app
-```
-
-### Running Projects
-
-```bash
-# Run a Go application
-nx serve my-go-app
-```
-
-### Testing Projects
-
-```bash
-# Test a Go project
-nx test my-go-app
-```
-
-## Generators & executors
-
-### Generators
-
-| Generator | Description |
-| -------------------------------------------- | --------------------------------------------- |
-| [`application`](../generators/application) | Generate a Go application |
-| [`go-blueprint`](../generators/go-blueprint) | Generate Go applications using Go Blueprint |
-| [`library`](../generators/library) | Generate a Go library |
-| [`init`](../generators/init) | Initialize gonx in an existing workspace |
-| [`preset`](../generators/preset) | Preset generator for creating a new workspace |
-
-### Executors
-
-| Executor | Description |
-| ------------------------------------------------------- | ------------------------------------------------- |
-| [`build`](../executors/build) | Build a Go project |
-| [`generate`](../executors/generate) | Run code generation using go generate |
-| [`lint`](../executors/lint) | Format and lint a Go project |
-| [`serve`](../executors/serve) | Run a Go application |
-| [`test`](../executors/test) | Run tests of a Go project |
-| [`tidy`](../executors/tidy) | Ensures go.mod file matches a project source code |
-| [`nx-release-publish`](../executors/nx-release-publish) | Lists the module in the Go registry |
-
-:::tip
-You can run `nx list @naxodev/gonx` to view the list of plugin capabilities.
-:::
-
-Need more customization? See our [plugin configuration options](./docs/options.md).
-
-#### Release Configuration
-
-GoNx supports Nx's release process with Go's versioning conventions. We automatically set up project names to match their directory paths, which ensures compatibility with Go's release tagging convention (`projectRoot/vx.x.x`).
-
-To configure your workspace for releasing Go modules, add a configuration like this to your `nx.json`:
-
-```json
-{
- "release": {
- "projectsRelationship": "independent",
- "projects": ["your-go-project"],
- "releaseTagPattern": "{projectName}/v{version}", // important! this is the Go release tag pattern
- "changelog": {
- ...
- },
- "version": {
- "useLegacyVersioning": false, // important! this means that we are using the plugin version actions
- ...
- },
- }
-}
-```
-
-Key configuration points:
-
-- `releaseTagPattern`: Set to `{projectName}/v{version}` to create Go-compatible tags (e.g., `apps/myapp/v1.2.3`)
-- `projectName`: With gonx, this is the full path to your project, not just the directory name
-
-See the [nx-release-publish executor docs](./docs/executors/nx-release-publish.md) for more information.
-
-## Contributors
-
-Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):
-
-
-
-
-
+
+{/* ── Scrollable nav ─────────────────────────────────────────────── */}
+
+
+
+
+{/* ── Bottom bar (all breakpoints) ────────────────────────────────── */}
+
+
+
+
+
+
+
+
diff --git a/docs/nx-cloudflare-docs/src/components/ThemeSelect.astro b/docs/nx-cloudflare-docs/src/components/ThemeSelect.astro
new file mode 100644
index 000000000..dfab84dbf
--- /dev/null
+++ b/docs/nx-cloudflare-docs/src/components/ThemeSelect.astro
@@ -0,0 +1,119 @@
+---
+---
+
+
+
+
+
+{/* Inlined to avoid FOUC. Uses global scope from ThemeProvider.astro */}
+
+
+
+
+
diff --git a/docs/nx-cloudflare-docs/src/content.config.ts b/docs/nx-cloudflare-docs/src/content.config.ts
new file mode 100644
index 000000000..6a7b7a02b
--- /dev/null
+++ b/docs/nx-cloudflare-docs/src/content.config.ts
@@ -0,0 +1,7 @@
+import { defineCollection } from 'astro:content';
+import { docsLoader } from '@astrojs/starlight/loaders';
+import { docsSchema } from '@astrojs/starlight/schema';
+
+export const collections = {
+ docs: defineCollection({ loader: docsLoader(), schema: docsSchema() }),
+};
diff --git a/docs/nx-cloudflare-docs/src/content/docs/community/migration.md b/docs/nx-cloudflare-docs/src/content/docs/community/migration.md
new file mode 100644
index 000000000..4df97f2dc
--- /dev/null
+++ b/docs/nx-cloudflare-docs/src/content/docs/community/migration.md
@@ -0,0 +1,95 @@
+---
+title: Migrate to 7.0.0
+description: How to migrate to @naxodev/nx-cloudflare 7.0.0 — inferred targets and Next.js removal.
+---
+
+import { Steps } from '@astrojs/starlight/components';
+
+7.0.0 replaces the old `serve`/`deploy`/`publish`/`next-build` executors with
+targets inferred from your Wrangler config, and removes the Next.js + webpack
+integration entirely. Two migrations handle the transition: one deterministic,
+one prompt-based.
+
+## Before you start
+
+- Commit any uncommitted work. The migration modifies `nx.json` and project
+ `project.json`/`package.json` files.
+- Review the [inferred targets reference](/guides/targets-serve) to understand what
+ the new targets look like.
+
+## Steps
+
+
+
+1. **Generate the migration file**
+
+ Run `nx migrate` against the new version:
+
+ ```bash
+ bunx nx migrate @naxodev/nx-cloudflare
+ ```
+
+ Nx generates a `migrations.json` file listing the migrations to apply and
+ the dependency version bumps (Nx 23, Wrangler v4.98). Review it before
+ proceeding.
+
+2. **Apply the deterministic migration**
+
+ The `update-7-0-0-move-to-inference` migration runs automatically. It
+ removes any project target whose executor is `@naxodev/nx-cloudflare:serve`,
+ `:deploy`, `:publish`, or `:next-build`, and registers
+ `@naxodev/nx-cloudflare/plugin` in `nx.json` so those targets are re-provided
+ as inferred targets.
+
+ ```bash
+ bunx nx migrate --run-migrations
+ ```
+
+ If you had customized a removed target with executor options (e.g. `port`,
+ `vars`, `routes`, `compatibility*`), the migration logs a warning naming the
+ dropped option keys. Move that configuration into your Wrangler config
+ (`wrangler.jsonc`/`.toml`), where Wrangler reads it natively, or pass it as
+ command-line args to the inferred target.
+
+3. **Remove Next.js references**
+
+ The `update-7-0-0-drop-nextjs` migration is prompt-based — it generates
+ instructions but does not modify files automatically. Search the workspace
+ for references to the deleted symbols and remove or replace them:
+
+ - **`next.config.js` / `next.config.mjs`** — remove imports of `withNx` or
+ `composePlugins` from `@naxodev/nx-cloudflare`. If the config only existed
+ to wrap Next.js for Cloudflare via this plugin, delete the wrapper and keep
+ a plain Next.js config.
+ - **`package.json`** — drop any `@naxodev/nx-cloudflare`-based Next.js build
+ scripts that called the `next-build` executor or the webpack composition.
+ - **Choose a replacement path for Next.js on Cloudflare.** This plugin no
+ longer provides one. The Cloudflare-recommended approach is
+ [`@opennextjs/cloudflare`](https://opennext.js.org/cloudflare) (OpenNext),
+ which builds a Next.js app into a Cloudflare Worker. Migrate to it, or to
+ Cloudflare Pages, as appropriate.
+
+ Non-Next.js Workers are unaffected — only touch projects that referenced the
+ removed symbols.
+
+
+
+## Verify
+
+Confirm the inferred targets resolve for each affected project:
+
+```bash
+bunx nx show project
+```
+
+Check that `serve`, `deploy`, `typegen`, `version-upload`, and `tail` appear as
+targets, and that no target references `@naxodev/nx-cloudflare:next-build`.
+
+## Next steps
+
+- [Inferred targets reference](/guides/targets-serve) — `serve`, `deploy`, `typegen`,
+ `version-upload`, `tail`
+- [How Wrangler config inference works](/understanding/wrangler) — why targets
+ are inferred from your Wrangler config
+- [Plugin options](/understanding/plugin-options) — customizing inferred target
+ names
diff --git a/docs/nx-cloudflare-docs/src/content/docs/getting-started/installation.md b/docs/nx-cloudflare-docs/src/content/docs/getting-started/installation.md
new file mode 100644
index 000000000..ebfe63e90
--- /dev/null
+++ b/docs/nx-cloudflare-docs/src/content/docs/getting-started/installation.md
@@ -0,0 +1,76 @@
+---
+title: Install Nx Cloudflare
+description: How to install and configure @naxodev/nx-cloudflare in your workspace.
+---
+
+import { Steps } from '@astrojs/starlight/components';
+
+## Prerequisites
+
+- **Node.js 20 or later** — required by Nx and Wrangler.
+- An existing Nx workspace. If you don't have one, create it with
+ `bunx create-nx-workspace@latest`.
+- A package manager: **bun**, npm, yarn, or pnpm. Examples below use `bunx`.
+
+## Steps
+
+
+
+1. **Add the plugin**
+
+ The recommended way is `nx add`, which installs the package and runs the
+ [`init` generator](/guides/generators-init) to set up workspace-level
+ dependencies and register the inference plugin:
+
+ ```bash
+ bunx nx add @naxodev/nx-cloudflare
+ ```
+
+ This installs Wrangler v4, `@cloudflare/workers-types`, and Vitest as
+ devDependencies, and adds `@naxodev/nx-cloudflare/plugin` to the `plugins`
+ array in `nx.json` so Worker targets are inferred automatically.
+
+2. **(Alternative) Install manually**
+
+ If you prefer to control setup yourself, install the package and Wrangler
+ separately, then register the plugin in `nx.json`:
+
+ ```bash
+ bun add -D @naxodev/nx-cloudflare wrangler
+ ```
+
+ Then add the plugin to `nx.json`:
+
+ ```json title="nx.json"
+ {
+ "plugins": ["@naxodev/nx-cloudflare/plugin"]
+ }
+ ```
+
+ See [Plugin options](/understanding/plugin-options) for the object form if
+ you need to customize inferred target names.
+
+3. **Verify the plugin is registered**
+
+ Confirm Nx recognizes the plugin by refreshing the project graph and
+ inspecting a Worker project (once you have one):
+
+ ```bash
+ bunx nx reset
+ bunx nx show project
+ ```
+
+ The output should list `serve`, `deploy`, `typegen`, `version-upload`, and
+ `tail` targets. If you don't have a Worker yet, the
+ [Quick start](/getting-started/quick-start) walks through generating one.
+
+
+
+## Next steps
+
+- [Quick start](/getting-started/quick-start) — create, serve, and deploy your
+ first Worker.
+- [application generator](/guides/generators-application) — scaffold a Worker
+ application with C3.
+- [Plugin options](/understanding/plugin-options) — customize inferred target
+ names.
diff --git a/docs/nx-cloudflare-docs/src/content/docs/getting-started/introduction.md b/docs/nx-cloudflare-docs/src/content/docs/getting-started/introduction.md
new file mode 100644
index 000000000..2fbcee793
--- /dev/null
+++ b/docs/nx-cloudflare-docs/src/content/docs/getting-started/introduction.md
@@ -0,0 +1,27 @@
+---
+title: Introduction
+description: What is Nx Cloudflare and what can it do for you?
+---
+
+`@naxodev/nx-cloudflare` is an Nx plugin for [Cloudflare Workers](https://developers.cloudflare.com/workers/).
+It brings Workers into an Nx workspace so you can scaffold, serve, deploy, and
+maintain Worker projects alongside the rest of your monorepo — with the caching,
+affected-detection, and project graph that Nx provides.
+
+The plugin infers Worker lifecycle targets (`serve`, `deploy`, `typegen`,
+`version-upload`, `tail`) directly from each project's Wrangler config, so there
+are no hand-written `project.json` targets to maintain. Scaffolding is handled
+by generators that wrap Cloudflare's [create-cloudflare (C3)](https://developers.cloudflare.com/workers/get-started/create-worker/)
+CLI, producing Nx-ready projects with `wrangler.jsonc`, TypeScript, and Vitest
+pre-configured.
+
+It's for teams and individuals already using Nx who want first-class Cloudflare
+Workers support in their workspace — whether that's a single Worker or a fleet
+of them shared across libraries, bindings, and shared logic.
+
+## Where to go next
+
+- New to the plugin? Walk through the [Quick start](/getting-started/quick-start)
+ to create, serve, and deploy a Worker in a few minutes.
+- Already know what you need? See [Installation](/getting-started/installation)
+ to add the plugin to an existing workspace.
diff --git a/docs/nx-cloudflare-docs/src/content/docs/getting-started/quick-start.md b/docs/nx-cloudflare-docs/src/content/docs/getting-started/quick-start.md
new file mode 100644
index 000000000..4aac79f0d
--- /dev/null
+++ b/docs/nx-cloudflare-docs/src/content/docs/getting-started/quick-start.md
@@ -0,0 +1,121 @@
+---
+title: Create your first Cloudflare Worker
+description: How to create, serve, and deploy a Cloudflare Worker with Nx.
+---
+
+import { Steps } from '@astrojs/starlight/components';
+
+In this tutorial, we'll create a Cloudflare Worker, serve it locally, and deploy
+it to Cloudflare — all from an Nx workspace.
+
+## Before you start
+
+- **Node.js 20 or later** — required by Nx and Wrangler.
+- **A Cloudflare account** — needed for deployment. Sign up at
+ [dash.cloudflare.com](https://dash.cloudflare.com/sign-up).
+- **Wrangler v4** — installed automatically when we add the plugin.
+
+## Compatibility
+
+| Nx version | Plugin version |
+| ---------- | -------------- |
+| 17.x | 1.x |
+| 18.x | 2.x |
+| 19.x | 3.x |
+| 20.x | 4.x |
+| 21.x | 5.x |
+| 22–23.x | 6.x |
+
+Wrangler v4 is a peer dependency. The `init` generator installs it
+automatically; if you add the plugin manually, install it with
+`bun add -D wrangler`.
+
+## Steps
+
+
+
+1. **Add the plugin to our workspace**
+
+ We'll use `nx add`, which installs the package and runs the
+ [`init` generator](/guides/generators-init) to set up workspace-level dependencies
+ and register the inference plugin in `nx.json`:
+
+ ```bash
+ bunx nx add @naxodev/nx-cloudflare
+ ```
+
+ This installs Wrangler v4, `@cloudflare/workers-types`, and Vitest as
+ devDependencies, and adds `@naxodev/nx-cloudflare/plugin` to the `plugins`
+ array in `nx.json` so Worker targets are inferred automatically.
+
+2. **Generate a Worker**
+
+ We'll scaffold a hello-world Worker using the
+ [application generator](/guides/generators-application), which wraps Cloudflare's
+ create-cloudflare (C3) CLI and makes the result Nx-ready:
+
+ ```bash
+ bunx nx g @naxodev/nx-cloudflare:application my-worker --type=hello-world
+ ```
+
+ The generator creates a `my-worker/` directory with a `wrangler.jsonc`
+ config, a `src/index.ts` entry point, and a `package.json` that registers
+ the project with Nx. It also retargets the Wrangler `$schema` to the
+ workspace root and strips redundant package scripts.
+
+3. **Serve the Worker locally**
+
+ Now we can run the Worker in a local dev server:
+
+ ```bash
+ bunx nx serve my-worker
+ ```
+
+ This runs `wrangler dev` from the project root. The server is ready when
+ Wrangler prints `Ready on http://localhost:8787`. Open that URL to see the
+ Worker's response.
+
+4. **Deploy to Cloudflare**
+
+ When we're ready to deploy, we run:
+
+ ```bash
+ bunx nx deploy my-worker
+ ```
+
+ This runs `wrangler deploy`, which uploads the Worker to Cloudflare's edge
+ network. On first deploy, Wrangler opens a browser to authenticate with your
+ Cloudflare account. Pass Wrangler flags through after `--`:
+
+ ```bash
+ bunx nx deploy my-worker -- --dry-run
+ ```
+
+ The `--dry-run` flag validates the deployment without publishing.
+
+
+
+## Verify
+
+Confirm the inferred targets resolved correctly:
+
+```bash
+bunx nx show project my-worker
+```
+
+This lists `serve`, `deploy`, `typegen`, `version-upload`, and `tail`,
+confirming the plugin registered the project.
+
+To verify the deployment, visit the Worker's URL. Wrangler prints the URL on
+successful deploy (e.g. `https://my-worker..workers.dev`).
+
+## Next steps
+
+- [Application generator reference](/guides/generators-application) — all scaffolding
+ options (templates, frameworks, languages)
+- [Inferred targets reference](/guides/targets-serve) — `serve`, `deploy`, `typegen`,
+ `version-upload`, `tail`
+- [How Wrangler config inference works](/understanding/wrangler) — why the
+ plugin reads your Wrangler config
+- [Plugin options](/understanding/plugin-options) — customizing inferred target
+ names
diff --git a/docs/nx-cloudflare-docs/src/content/docs/guides/generators-application.md b/docs/nx-cloudflare-docs/src/content/docs/guides/generators-application.md
new file mode 100644
index 000000000..a5cbe9a0c
--- /dev/null
+++ b/docs/nx-cloudflare-docs/src/content/docs/guides/generators-application.md
@@ -0,0 +1,41 @@
+---
+title: application generator
+description: Scaffold a Cloudflare Worker with create-cloudflare (C3) and make it Nx-ready.
+---
+
+The `create-cloudflare` generator wraps Cloudflare's [create-cloudflare (C3)](https://developers.cloudflare.com/workers/get-started/create-worker/) CLI to scaffold a Worker project, then makes it Nx-ready with Wrangler target inference and workspace-managed dependencies.
+
+**Aliases:** `c3`, `application`, `app`
+
+## Usage
+
+```bash
+bunx nx g @naxodev/nx-cloudflare:application my-worker
+```
+
+## Options
+
+| Option | Type | Default | Description |
+| ---------------- | ------------------------ | ------------ | --------------------------------------------------------------------------------------------------------------------------------------------- |
+| `directory` | string | _(required)_ | The directory of the new application. Takes the first positional argument. |
+| `name` | string | | The name of the application. Must match `^[a-zA-Z][^:]*$`. |
+| `type` | string | | Worker template forwarded to C3 `--type` (e.g. `hello-world`, `hello-world-durable-object`, `scheduled`, `queues`, `openapi`). |
+| `framework` | string | | Web framework forwarded to C3 `--framework` (e.g. `react`, `hono`, `next`, `astro`, `svelte`, `vue`). |
+| `template` | string | | Remote git template forwarded to C3 `--template`. |
+| `lang` | `ts` \| `js` \| `python` | `ts` | Language of the generated scaffold, forwarded to C3 `--lang`. |
+| `c3Version` | string | `2.70.0` | Override the pinned create-cloudflare version to invoke. |
+| `c3Args` | string[] | | Additional raw flags forwarded to C3. Generator-controlled flags (`git`, `deploy`, `open`, `auto-update`) cannot be overridden. |
+| `tags` | string | | Comma-separated tags added to the application (used for linting). |
+| `useProjectJson` | boolean | `false` | Write an explicit `project.json`. Off by default — the worker is registered from its `package.json` and Wrangler config via target inference. |
+| `skipFormat` | boolean | `false` | Skip formatting files. |
+
+## Notes
+
+Provide exactly one of `type`, `framework`, or `template` to control the C3 scaffold non-interactively. If none are provided, C3's interactive prompts guide selection.
+
+## Next steps
+
+- [Inferred targets](/guides/targets-serve) — `serve`, `deploy`, `typegen`, `version-upload`, `tail`
+- [Plugin options](/understanding/plugin-options) — customizing inferred target names
+- [Wrangler config](/understanding/wrangler) — config formats and inference
+- [library generator](/guides/generators-library) — scaffold a Worker library
diff --git a/docs/nx-cloudflare-docs/src/content/docs/guides/generators-init.md b/docs/nx-cloudflare-docs/src/content/docs/guides/generators-init.md
new file mode 100644
index 000000000..cbfb0f3fb
--- /dev/null
+++ b/docs/nx-cloudflare-docs/src/content/docs/guides/generators-init.md
@@ -0,0 +1,45 @@
+---
+title: init generator
+description: Initialize the Nx Cloudflare plugin in an existing workspace.
+---
+
+The `init` generator sets up workspace-level dependencies and plugin registration for Cloudflare Workers development with Nx, running automatically via `nx add @naxodev/nx-cloudflare` and from the `application` and `library` generators.
+
+## Usage
+
+```bash
+bunx nx g @naxodev/nx-cloudflare:init
+```
+
+## Options
+
+| Option | Type | Default | Description |
+| ---------------- | ---------------------------- | ------------ | ------------------------------------------------------ |
+| `name` | string | _(required)_ | The name of the workspace. Forwarded to `@nx/js:init`. |
+| `unitTestRunner` | `vitest` \| `jest` \| `none` | `vitest` | Test runner to use for unit tests. |
+| `js` | boolean | `false` | Use JavaScript instead of TypeScript. |
+| `skipFormat` | boolean | `false` | Skip formatting files. |
+
+## Installed dependencies
+
+The `init` generator runs `@nx/js:init` first, then adds the following packages:
+
+| Package | Scope | Pinned version |
+| --------------------------------- | ------------- | --------------- |
+| `tslib` | dependency | `^2.3.0` |
+| `wrangler` | devDependency | `^4.98.0` |
+| `@cloudflare/workers-types` | devDependency | `^4.20260606.1` |
+| `@cloudflare/vitest-pool-workers` | devDependency | `^0.16.0` |
+| `vitest` | devDependency | `^4.1.0` |
+
+It also registers `@naxodev/nx-cloudflare/plugin` in `nx.json` so that Worker lifecycle targets (`serve`, `deploy`, `typegen`, `version-upload`, `tail`) are inferred from Wrangler configs.
+
+## Notes
+
+The `init` generator does not re-add `@naxodev/nx-cloudflare` itself to `package.json` — the plugin invoking the generator is already installed.
+
+## Next steps
+
+- [application generator](/guides/generators-application) — scaffold a Worker application
+- [library generator](/guides/generators-library) — scaffold a Worker library
+- [Plugin options](/understanding/plugin-options) — inferred target names
diff --git a/docs/nx-cloudflare-docs/src/content/docs/guides/generators-library.md b/docs/nx-cloudflare-docs/src/content/docs/guides/generators-library.md
new file mode 100644
index 000000000..32b67ce5c
--- /dev/null
+++ b/docs/nx-cloudflare-docs/src/content/docs/guides/generators-library.md
@@ -0,0 +1,49 @@
+---
+title: library generator
+description: Generate a Cloudflare Worker library with Workers runtime types.
+---
+
+The `library` generator creates a Cloudflare Worker library — a shareable package with Workers runtime types, suitable for shared logic, bindings, or utilities consumed by Worker applications.
+
+**Alias:** `lib`
+
+## Usage
+
+```bash
+bunx nx g @naxodev/nx-cloudflare:library my-worker-lib
+```
+
+## Options
+
+| Option | Type | Default | Description |
+| ------------------------- | ----------------------------------------------- | ------------ | ---------------------------------------------------------------------------------------------- |
+| `directory` | string | _(required)_ | The directory of the new library. Takes the first positional argument. |
+| `name` | string | | The name of the library. Must match `^[a-zA-Z][^:]*$`. |
+| `linter` | `eslint` \| `none` | `eslint` | The tool to use for running lint checks. |
+| `unitTestRunner` | `vitest` \| `none` | _(prompted)_ | Test runner to use for unit tests. |
+| `bundler` | `swc` \| `tsc` \| `vite` \| `esbuild` \| `none` | `tsc` | The bundler to use. `none` means the library is not buildable. |
+| `publishable` | boolean | `false` | Generate a publishable library. |
+| `importPath` | string | | The library name used to import it (e.g. `@myorg/my-lib`). Required for publishable libraries. |
+| `js` | boolean | `false` | Generate JavaScript files rather than TypeScript files. |
+| `strict` | boolean | `true` | Enable tsconfig strict mode. |
+| `tags` | string | | Comma-separated tags added to the library (used for linting). |
+| `minimal` | boolean | `false` | Generate a library with minimal setup. No README.md generated. |
+| `simpleName` | boolean | `false` | Don't include the directory in the generated file name. |
+| `config` | `workspace` \| `project` \| `npm-scripts` | `project` | Where to configure the project's executors. |
+| `skipFormat` | boolean | `false` | Skip formatting files. |
+| `skipPackageJson` | boolean | `false` | Do not add dependencies to `package.json`. |
+| `skipTsConfig` | boolean | `false` | Do not update `tsconfig.json` for development experience. |
+| `skipTypeCheck` | boolean | `false` | Skip TypeScript type checking for SWC compiler. |
+| `setParserOptionsProject` | boolean | `false` | Configure the ESLint `parserOptions.project` option. Off by default for lint performance. |
+
+## Notes
+
+Publishable libraries require `importPath` and cannot use `bundler=none`. Non-publishable libraries have `bundler` forced to `none` (not buildable) regardless of the value passed.
+
+Worker libraries have no Wrangler config, so no inferred targets are generated (`serve`, `deploy`, `typegen`, etc. are not available). Workers runtime types come from `@cloudflare/workers-types` via `tsconfig.lib.json`, not a generated `worker-configuration.d.ts`.
+
+## Next steps
+
+- [application generator](/guides/generators-application) — scaffold a Worker application
+- [init generator](/guides/generators-init) — workspace-level setup
+- [Plugin options](/understanding/plugin-options) — inferred target names
diff --git a/docs/nx-cloudflare-docs/src/content/docs/guides/targets-deploy.md b/docs/nx-cloudflare-docs/src/content/docs/guides/targets-deploy.md
new file mode 100644
index 000000000..a580fa9a5
--- /dev/null
+++ b/docs/nx-cloudflare-docs/src/content/docs/guides/targets-deploy.md
@@ -0,0 +1,31 @@
+---
+title: deploy
+description: Inferred target that runs wrangler deploy to publish a Worker to Cloudflare's edge.
+---
+
+The `deploy` target runs `wrangler deploy` from the project root, publishing the Worker to Cloudflare's edge network.
+
+## Usage
+
+```bash
+nx deploy
+```
+
+## Behavior
+
+- **Command:** `wrangler deploy`
+- **Continuous:** no
+
+## Passing flags
+
+```bash
+nx deploy -- --dry-run
+nx deploy -- --name my-custom-worker
+```
+
+## Next steps
+
+- [version-upload target](/guides/targets-version-upload) for gradual deployments
+- [Wrangler config and target inference](/understanding/wrangler)
+- [Plugin options](/understanding/plugin-options)
+- [`wrangler deploy` CLI docs](https://developers.cloudflare.com/workers/wrangler/commands/#deploy)
diff --git a/docs/nx-cloudflare-docs/src/content/docs/guides/targets-serve.md b/docs/nx-cloudflare-docs/src/content/docs/guides/targets-serve.md
new file mode 100644
index 000000000..c175f1799
--- /dev/null
+++ b/docs/nx-cloudflare-docs/src/content/docs/guides/targets-serve.md
@@ -0,0 +1,34 @@
+---
+title: serve
+description: Inferred target that runs wrangler dev to start a local Worker development server.
+---
+
+The `serve` target runs `wrangler dev` from the project root, starting a continuous local development server for the Worker.
+
+## Usage
+
+```bash
+nx serve
+```
+
+## Behavior
+
+- **Command:** `wrangler dev`
+- **Continuous:** yes
+- **Ready signal:** considered ready when Wrangler prints `Ready on http://...`, so dependent tasks wait for the server to be listening.
+
+The dev server port is set via `dev.port` in the Wrangler config and defaults to `8787`.
+
+## Passing flags
+
+```bash
+nx serve -- --remote
+nx serve -- --ip 0.0.0.0
+```
+
+## Next steps
+
+- [deploy target](/guides/targets-deploy)
+- [Wrangler config and target inference](/understanding/wrangler)
+- [Plugin options](/understanding/plugin-options)
+- [`wrangler dev` CLI docs](https://developers.cloudflare.com/workers/wrangler/commands/#dev)
diff --git a/docs/nx-cloudflare-docs/src/content/docs/guides/targets-tail.md b/docs/nx-cloudflare-docs/src/content/docs/guides/targets-tail.md
new file mode 100644
index 000000000..2b1a941d4
--- /dev/null
+++ b/docs/nx-cloudflare-docs/src/content/docs/guides/targets-tail.md
@@ -0,0 +1,32 @@
+---
+title: tail
+description: Inferred target that runs wrangler tail to stream live logs from a deployed Worker.
+---
+
+The `tail` target runs `wrangler tail` from the project root, streaming live logs from a deployed Worker in real time. For local development, use [serve](/guides/targets-serve) instead and read the terminal output directly.
+
+## Usage
+
+```bash
+nx tail
+```
+
+## Behavior
+
+- **Command:** `wrangler tail`
+- **Continuous:** yes
+
+## Passing flags
+
+```bash
+nx tail -- --status error
+nx tail -- --format json
+```
+
+## Next steps
+
+- [serve target](/guides/targets-serve)
+- [deploy target](/guides/targets-deploy)
+- [Wrangler config and target inference](/understanding/wrangler)
+- [Plugin options](/understanding/plugin-options)
+- [`wrangler tail` CLI docs](https://developers.cloudflare.com/workers/wrangler/commands/#tail)
diff --git a/docs/nx-cloudflare-docs/src/content/docs/guides/targets-typegen.md b/docs/nx-cloudflare-docs/src/content/docs/guides/targets-typegen.md
new file mode 100644
index 000000000..65ad879cb
--- /dev/null
+++ b/docs/nx-cloudflare-docs/src/content/docs/guides/targets-typegen.md
@@ -0,0 +1,35 @@
+---
+title: typegen
+description: Inferred target that runs wrangler types to generate worker-configuration.d.ts.
+---
+
+The `typegen` target runs `wrangler types` from the project root, generating `worker-configuration.d.ts` — the typed `Env` interface and Workers runtime types derived from the Wrangler config.
+
+## Usage
+
+```bash
+nx typegen
+```
+
+## Behavior
+
+- **Command:** `wrangler types`
+- **Continuous:** no
+- **Cached:** yes
+- **Inputs:** project files, upstream project files, and the `wrangler` external dependency
+- **Outputs:** `{projectRoot}/worker-configuration.d.ts`
+
+`worker-configuration.d.ts` is a generated artifact and is git-ignored. The `typegen` target is inferred only for Worker applications (projects with a Wrangler config); Worker libraries do not have one.
+
+## Passing flags
+
+```bash
+nx typegen -- --name MyEnv
+```
+
+## Next steps
+
+- [serve target](/guides/targets-serve)
+- [Wrangler config and target inference](/understanding/wrangler)
+- [Plugin options](/understanding/plugin-options)
+- [`wrangler types` CLI docs](https://developers.cloudflare.com/workers/wrangler/commands/#types)
diff --git a/docs/nx-cloudflare-docs/src/content/docs/guides/targets-version-upload.md b/docs/nx-cloudflare-docs/src/content/docs/guides/targets-version-upload.md
new file mode 100644
index 000000000..95682ef12
--- /dev/null
+++ b/docs/nx-cloudflare-docs/src/content/docs/guides/targets-version-upload.md
@@ -0,0 +1,30 @@
+---
+title: version-upload
+description: Inferred target that runs wrangler versions upload to publish a new Worker version.
+---
+
+The `version-upload` target runs `wrangler versions upload` from the project root, uploading a new version of the Worker to Cloudflare's Versions API. This is the foundation for gradual deployments — rolling out new versions incrementally and rolling back instantly.
+
+## Usage
+
+```bash
+nx version-upload
+```
+
+## Behavior
+
+- **Command:** `wrangler versions upload`
+- **Continuous:** no
+
+## Passing flags
+
+```bash
+nx version-upload -- --message "fix: update handler"
+```
+
+## Next steps
+
+- [deploy target](/guides/targets-deploy)
+- [Wrangler config and target inference](/understanding/wrangler)
+- [Plugin options](/understanding/plugin-options)
+- [Wrangler versions docs](https://developers.cloudflare.com/workers/wrangler/commands/#versions)
diff --git a/docs/nx-cloudflare-docs/src/content/docs/index.mdx b/docs/nx-cloudflare-docs/src/content/docs/index.mdx
new file mode 100644
index 000000000..dbbaccd1f
--- /dev/null
+++ b/docs/nx-cloudflare-docs/src/content/docs/index.mdx
@@ -0,0 +1,85 @@
+---
+title: Nx Cloudflare documentation
+description: Nx plugin for Cloudflare Workers
+template: splash
+hero:
+ tagline: An Nx plugin for Cloudflare Workers
+---
+
+import { Card, CardGrid } from '@astrojs/starlight/components';
+
+
+
+
+
+
+
+
+
+ An Nx plugin for [Cloudflare Workers](/getting-started/quick-start) with inferred
+ targets, C3-powered scaffolding, and Wrangler v4 support. Available on [npm](https://www.npmjs.com/package/@naxodev/nx-cloudflare).
+
+
+ The plugin is open source. See the [GitHub
+ repository](https://github.com/naxodev/oss/tree/main/packages/nx-cloudflare).
+
+
+ Join the [Discord server](https://discord.gg/zjDCGpKP2S) for discussion and
+ support.
+
+
+
+---
+
+## Key Features
+
+
+
+
Inferred Worker Targets
+
+ Serve, deploy, typegen, version-upload, and tail targets are inferred from
+ your Wrangler config — no hand-written project.json targets needed.
+
+
+
+{' '}
+
+
+
C3-Powered Scaffolding
+
+ The application generator wraps Cloudflare's create-cloudflare (C3) CLI,
+ then makes the scaffolded project Nx-ready.
+
+
+
+{' '}
+
+
+
Wrangler v4 + JSONC
+
+ Generates wrangler.jsonc by default with $schema validation. Supports
+ jsonc, toml, and json config formats.
+
+