Neon.Website reference

Astro

Source: src/Neon/Website/Astro.ts

Astro SSR and prerendered pages on Neon Functions. The Node target owns the adapter; omit adapter from astro.config.*. Set astro.output to “static” to prerender every page.

Astro: Creating a Website

const site = yield* Neon.Website.Astro("Web", {
  rootDir: "./app",
});

Astro: Deployment Configuration

const site = yield* Neon.Website.Astro("Web", {
  project,
  domain: "www.example.com",
  env: { API_BASE: "https://api.example.com" },
  function: { name: "Website" },
});

Astro: Static Output

const docs = yield* Neon.Website.Astro("Docs", {
  rootDir: "./docs",
  astro: { output: "static" },
  assets: { notFoundHandling: "404-page" },
});

Foldkit

Source: src/Neon/Website/Foldkit.ts

Deploy a Foldkit Vite application to Neon Functions with SPA routing. The project’s Foldkit Vite plugin drives the build; native Vite HMR runs during development without creating cloud resources.

Foldkit: Creating a Website

const site = yield* Neon.Website.Foldkit("Web", {
  rootDir: "./app",
});

Foldkit: Multi-Page Routing

const site = yield* Neon.Website.Foldkit("Web", {
  assets: { notFoundHandling: "404-page" },
});

Nextjs

Source: src/Neon/Website/Nextjs.ts

Next.js on Neon Functions using next build and the existing Node custom-server target, not OpenNext. The artifact contains .next, public, configuration, and traced runtime dependencies, preserving installed package versions.

Native framework development and HMR run without Neon cloud resources. Apply Alchemy.remote() to use the live Function deployment during dev. Packaging requires the optional @vercel/nft peer dependency. Exact-version Sharp Linux ARM64/glibc packages are integrity-checked and staged. The example artifact passes isolated Node 24 image optimization and desktop/mobile counter, server-action, and redirect navigation checks. The Fetch bridge preserves request-origin metadata without rewriting redirect responses. Initial live deployment and desktop/mobile interactions are verified. Updates may still serve the previous artifact after Neon accepts a new deployment; full lifecycle acceptance remains incomplete.

Nextjs: Creating a Website

const site = yield* Neon.Website.Nextjs("Web", {
  rootDir: "./app",
});

Nextjs: Deployment Configuration

const site = yield* Neon.Website.Nextjs("Web", {
  project,
  domain: "www.example.com",
  env: { API_BASE: "https://api.example.com" },
  function: { name: "Website" },
});

Nuxt

Source: src/Neon/Website/Nuxt.ts

Nuxt SSR and prerendered assets on Neon Functions. The Node target owns Nitro’s node preset; do not override nitro.preset.

Nuxt: Creating a Website

const site = yield* Neon.Website.Nuxt("Web", {
  rootDir: "./app",
});

Nuxt: Deployment Configuration

const site = yield* Neon.Website.Nuxt("Web", {
  project,
  domain: "www.example.com",
  env: { API_BASE: "https://api.example.com" },
  function: { name: "Website" },
});

Octane

Source: src/Neon/Website/Octane.ts

Octane SSR and client assets on Neon Functions. Select node() from @alchemy.run/frontend-frameworks/octane/node-adapter in the project’s octane.config.ts.

Octane: Creating a Website

const site = yield* Neon.Website.Octane("Web", {
  rootDir: "./app",
});

Octane: Deployment Configuration

const site = yield* Neon.Website.Octane("Web", {
  project,
  domain: "www.example.com",
  env: { API_BASE: "https://api.example.com" },
  function: { name: "Website" },
});

ReactRouter

Source: src/Neon/Website/ReactRouter.ts

React Router SSR and browser assets on Neon Functions using the existing Node framework target.

ReactRouter: Creating a Website

const site = yield* Neon.Website.ReactRouter("Web", {
  rootDir: "./app",
});

ReactRouter: Deployment Configuration

const site = yield* Neon.Website.ReactRouter("Web", {
  project,
  domain: "www.example.com",
  env: { API_BASE: "https://api.example.com" },
  function: { name: "Website" },
});

SolidStart

Source: src/Neon/Website/SolidStart.ts

SolidStart SSR and prerendered assets on Neon Functions. The integration owns the Nitro plugin; omit nitroV2Plugin() from vite.config.* and configure prerendering through nitro.

SolidStart: Creating a Website

const site = yield* Neon.Website.SolidStart("Web", {
  rootDir: "./app",
});

SolidStart: Deployment Configuration

const site = yield* Neon.Website.SolidStart("Web", {
  project,
  domain: "www.example.com",
  env: { API_BASE: "https://api.example.com" },
  function: { name: "Website" },
});

StaticSite

Source: src/Neon/Website/StaticSite.ts

Build a static website with a shell command and serve it on Neon Functions. Only the output directory is packaged; the repository is never uploaded. Native development declares no implicit Neon Project, Function, or custom domain. Alchemy.remote() opts into the live deployment during development.

StaticSite: Creating a Static Website

const site = yield* Neon.Website.StaticSite("Blog", {
  command: "hugo --minify",
  outdir: "public",
});

StaticSite: Monorepos and Development

const site = yield* Neon.Website.StaticSite("Web", {
  cwd: "apps/web",
  command: "npm run build",
  outdir: "dist",
  spa: true,
  dev: { command: "npm run dev" },
});

SvelteKit

Source: src/Neon/Website/SvelteKit.ts

SvelteKit SSR and prerendered assets on Neon Functions. The Node target injects the adapter. For Kit v3, pass configuration through kit rather than a svelte.config.js file.

SvelteKit: Creating a Website

const site = yield* Neon.Website.SvelteKit("Web", {
  rootDir: "./app",
});

SvelteKit: Deployment Configuration

const site = yield* Neon.Website.SvelteKit("Web", {
  project,
  domain: "www.example.com",
  env: { API_BASE: "https://api.example.com" },
  function: { name: "Website" },
});

TanStackStart

Source: src/Neon/Website/TanStackStart.ts

TanStack Start SSR and browser assets on Neon Functions using the existing Node framework target.

TanStackStart: Creating a Website

const site = yield* Neon.Website.TanStackStart("Web", {
  rootDir: "./app",
});

TanStackStart: Deployment Configuration

const site = yield* Neon.Website.TanStackStart("Web", {
  project,
  domain: "www.example.com",
  env: { API_BASE: "https://api.example.com" },
  function: { name: "Website" },
});

Vite

Source: src/Neon/Website/Vite.ts

Static Vite assets served on Neon Functions. The project’s Vite plugins and configuration drive the build; native Vite HMR runs during development.

Vite: Creating a Website

const site = yield* Neon.Website.Vite("Web", {
  rootDir: "./app",
});

Vite: Deployment Configuration

const site = yield* Neon.Website.Vite("Web", {
  project,
  domain: "www.example.com",
  env: { API_BASE: "https://api.example.com" },
  function: { name: "Website" },
});

Vocs

Source: src/Neon/Website/Vocs.ts

Vocs documentation and its Waku RSC handler on Neon Functions. Install Vocs and its Waku peers alongside the framework integration.

Native framework development and HMR run without Neon cloud resources. Apply Alchemy.remote() to use the live Function deployment during dev. Packaging requires the optional @vercel/nft peer dependency. The packaged example passes fresh Neon page, guide, and asset checks, plus live desktop/mobile counter interactions and guide navigation. Traced sensitive files remain rejected; diagnostics identify sanitized filenames. Native dev uses Vocs’s own Vite instance in an isolated process.

Vocs: Creating a Website

const site = yield* Neon.Website.Vocs("Web", {
  rootDir: "./app",
});

Vocs: Deployment Configuration

const site = yield* Neon.Website.Vocs("Web", {
  project,
  domain: "www.example.com",
  env: { API_BASE: "https://api.example.com" },
  function: { name: "Website" },
});

Waku

Source: src/Neon/Website/Waku.ts

Waku RSC and static pages on Neon Functions. The Node target selects Waku’s node adapter; do not set unstable_adapter.

Waku: Creating a Website

const site = yield* Neon.Website.Waku("Web", {
  rootDir: "./app",
});

Waku: Deployment Configuration

const site = yield* Neon.Website.Waku("Web", {
  project,
  domain: "www.example.com",
  env: { API_BASE: "https://api.example.com" },
  function: { name: "Website" },
});