fix(void): give Nuxt, Analog and deploy cron bundles the app's void/db

Nitro builds a Nuxt or Analog server without Void's Vite plugins, so
every server route got the static D1 client from `void/db`. A
PostgreSQL or MySQL app failed each database request with a missing
`DB` binding, and `db.query` was undefined even on D1 because the
client had no schema. The deploy build of hosted framework cron and
queue handlers had the same gap: it built `void/db` as the D1 client
and could not resolve `@schema`.

Nuxt and Analog apps now add `void/nitro` to their Nitro modules. The
module and the cron/queue handler build share the plugin that serves
the app's own `void/db`, with its dialect, schema and driver, and
resolve `@schema` through the bundler so a schema folder works. Their
Worker builds import a workerd build of pg or mysql2, made the same way
as the migration handler, because Nitro's CommonJS handling and Node
stubs break both drivers in workerd. The pg build loads no `node:fs`,
which workerd provides only from the 2025-09-15 compatibility date.
For PostgreSQL and MySQL the module also runs each request in Void's
request scope and keeps Void's `node:async_hooks` import native, so a
request reuses one pool across its queries instead of opening a
connection per query. The cron/queue handler build does the same for
each cron event and queue batch, as Void apps do. D1 apps keep their
current request and event handling.

A PostgreSQL or MySQL app with no schema file now gets its dialect's
`void/db` in Vite builds too. An app whose bundle still loads the D1
client while it has HYPERDRIVE or DATABASE_URL gets an error that says
to add `void/nitro`. `void init` prints the module step for Nuxt and
Analog. Nuxt apps keep the Nitro `@schema` alias, because Nuxt types
server routes from Nitro's aliases.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0123r5HnanmW2VUrZ7VWDufH

Author: Brooooooklyn

docs/guide/database.md

@@ -234,10 +234,6 @@ const usersWithPosts = await db.query.users.findMany({
 });
 ```
 
-::: warning ⚠️ Nuxt and Analog limitations
-In Nuxt and Analog, use the query builder (`db.select().from(table)`). The `db.query.*` relational API is not available in these frameworks.
-:::
-
 ## Seeding
 
 Use `void db seed` to reset your local database, re-apply migrations, and then run a seed file.

docs/integrations/frameworks/analog.md

@@ -26,7 +26,6 @@ Void provides the local Cloudflare binding runtime. `nitro-cloudflare-dev` creat
 ### 3. Configure `vite.config.ts`
 
 ```ts
-import { resolve } from 'node:path';
 import analog from '@analogjs/platform';
 import { defineConfig } from 'vite';
 import { voidPlugin } from 'void';
@@ -41,19 +40,16 @@ export default defineConfig({
       nitro: {
         preset: 'cloudflare-module',
         cloudflareDev: { configPath: './.void-wrangler.jsonc' },
-        modules: ['nitro-cloudflare-dev'],
-        alias: {
-          // Nitro has its own bundler that doesn't use Vite aliases.
-          // Duplicate @schema here so Nitro can resolve it.
-          '@schema': resolve(__dirname, 'db/schema.ts'),
-        },
+        modules: ['nitro-cloudflare-dev', 'void/nitro'],
       },
     }),
     voidPlugin(),
   ],
 });
 ```
 
+The `void/nitro` module gives Analog API routes and page server loads your app's `void/db` and `@schema`.
+
 ### 4. Create `void.config.ts`
 
 Void generates the Cloudflare config used by Analog's development runtime:
@@ -98,10 +94,6 @@ export const load = async ({ event }: PageServerLoad) => {
 };
 ```
 
-::: warning ⚠️ Analog limitation
-Use `db.select().from(table)` for database queries in Analog. The `db.query.*` relational API is not available.
-:::
-
 ### Other resources
 
 Use [KV](../../guide/kv.md), [object storage](../../guide/storage.md), and [AI](../../guide/ai.md) from server-side code with the same imports as a Void app. Add [cron jobs](../../guide/jobs.md) in `crons/` and [queue consumers](../../guide/queues.md) in `queues/`.

docs/integrations/frameworks/nuxt.md

@@ -32,21 +32,23 @@ import { voidPlugin } from 'void';
 export default defineNuxtConfig({
   nitro: {
     preset: 'cloudflare-module',
+    modules: ['void/nitro'],
     cloudflareDev: { configPath: './.void-wrangler.jsonc' },
     // Required for Nuxt 4.6.0 on Windows.
     externals: {
       inline: [/[\\/]node_modules[\\/]nuxt[\\/]dist[\\/]/],
     },
     alias: {
-      // Nitro has its own bundler that doesn't use Vite aliases.
-      // Duplicate @schema here so Nitro can resolve it.
+      // Nuxt types server routes from Nitro's aliases.
       '@schema': resolve(import.meta.dirname, 'db/schema.ts'),
     },
   },
   vite: { plugins: [voidPlugin()] },
 });
 ```
 
+The `void/nitro` module gives Nuxt server routes your app's `void/db` and `@schema`.
+
 ### 4. Create `void.config.ts`
 
 Void generates the Cloudflare config used by Nuxt's development runtime:
@@ -88,10 +90,6 @@ export default defineEventHandler(async () => {
 });
 ```
 
-::: warning ⚠️ Nuxt limitation
-Use `db.select().from(table)` for database queries in Nuxt. The `db.query.*` relational API is not available.
-:::
-
 ### Other resources
 
 Use [KV](../../guide/kv.md), [object storage](../../guide/storage.md), and [AI](../../guide/ai.md) from server-side code with the same imports as a Void app. Add [cron jobs](../../guide/jobs.md) in `crons/` and [queue consumers](../../guide/queues.md) in `queues/`.

docs/reference/api.md

@@ -68,4 +68,5 @@ Import Void's app-facing APIs from these paths:
 | `void/queues`             | `queues` proxy for sending messages to typed queues                                                                                                                                                                                                                                                                                                                                                                                                                            |
 | `void/sandbox`            | `getSandbox`, `sandbox`, `SandboxLimitError`, `SandboxUnavailableError`, and the SDK 1.0 file, backup, and mount helpers. `getSandbox(id)` resolves a client. Commands, files, port requests, and process completion return promises; limits reject with `SandboxLimitError`, which extends `UsageLimit`. Container state lasts until inactivity (default ten minutes), a crash, or a restart. See [Sandboxes](../guide/sandboxes.md) for the API and deployment requirements. |
 | `void/env`                | `defineEnv`, `env`, schema helpers (`string`, `number`, `boolean`, `url`, `email`, `oneOf`, `json`), and global Cloudflare env types                                                                                                                                                                                                                                                                                                                                           |
+| `void/nitro`              | Nitro module for Nuxt and Analog. Add `'void/nitro'` to the Nitro `modules` so server routes get the app's `void/db` and `@schema`                                                                                                                                                                                                                                                                                                                                             |
 | `void/sveltekit`          | SvelteKit integration helpers: `withVoidTSConfig()` and `mergeVoidSvelteKitTsconfig()`                                                                                                                                                                                                                                                                                                                                                                                         |

packages/void/AGENTS.md

@@ -102,7 +102,7 @@ generated entries must preserve the module-boundary rules below.
 - **pnpm scaffold build policy**: Keep `create-void` and `void init` aligned with the repository: `better-sqlite3: false` uses version 13's bundled Node-API binaries; `esbuild`, `sharp`, and `workerd` have approved builds. Do not require an unnecessary node-gyp rebuild in fresh applications.
 - **Scaffold dependency installation**: Vite+ projects install through local/global `vp`, bootstrapping with `npx` when neither is available. Preserve existing package-manager pins and lockfiles; fresh Vite+ projects select pnpm through the build-policy YAML without adding a version pin. Plain Vite projects use their selected package manager. Do not run a global package manager directly for Vite+ installs.
 - **Prerender discovery and environment validation**: Only `POST /__void/prerender-paths` bypasses whole-schema boot validation, because path discovery runs without remote production secrets. Discovery answers only when the build-time runner marks the request (the `__VOID_PRERENDER` Miniflare binding on Cloudflare, the Hono env argument on Node/Bun/Deno), never on a deployed app or dev server. Keep validation on readiness, application requests, page rendering, and event handlers.
-- **Pre-resolved paths in codegen**: Generated virtual module code uses absolute paths for `hono` and `void/response` (resolved via `import.meta.resolve()`). Virtual modules have no filesystem location, so bare specifiers can't resolve from them. void/db never imports its pg or mysql2 driver itself: drizzle builds the pool from `connection`, and the worker prebundle serves drizzle's bare driver import.
+- **Pre-resolved paths in codegen**: Generated virtual module code uses absolute paths for `hono` and `void/response` (resolved via `import.meta.resolve()`). Virtual modules have no filesystem location, so bare specifiers can't resolve from them. void/db never imports its pg or mysql2 driver itself: drizzle builds the pool from `connection`, and the worker prebundle serves drizzle's bare driver import. Bundles that never run Void's Vite plugins, Nitro (through `void/nitro`) and the deploy cron/queue handler build, get the same module from `voidDbBundlerPlugin`, which resolves `@schema` through the bundler so a schema folder works. Their Worker builds import the driver that `bundleWorkerSqlDriver` builds like the migration handler: Nitro's CommonJS handling and Node stubs break pg and mysql2 in workerd. For pg and MySQL, `void/nitro` also runs each request in `withRuntimeEnv` (as the Class A wrapper does) and keeps Void's `node:async_hooks` native in workerd builds, because Nitro's unenv AsyncLocalStorage drops the store after the first await. The deploy handler build likewise runs each cron event and queue batch in `withRuntimeEnv`.
 - **CF plugin API**: Worker config (`main`, `d1_databases`, `kv_namespaces`, `r2_buckets`) goes inside the `config` option of `cloudflare()`, NOT as top-level properties. `persistState` takes `{ path: string }`, not a raw string. The `config` option uses a **function form** `(resolved: WorkerConfig) => Partial<WorkerConfig>` so that bindings from the user's `wrangler.json` (if present) take precedence over inferred placeholder bindings.
 - **Direct deploy package boundary**: target-neutral intents, artifacts, resources, migrations, and Durable Object plans live in public `@void/deploy-core`; root Wrangler config parsing and verified Cloudflare upload primitives live in public `@void/deploy-cloudflare`. The CLI consumes both packages directly. Hosted platform packages consume `@void/deploy-core` and must not be imported by public SDK packages.
 - **Direct activation invariant**: native Cloudflare deploy uploads a Worker Version without traffic, records the validated migration filenames in its annotation, probes that version directly, activates it at 100%, and only then synchronizes triggers. A trigger-sync failure restores the prior active version. Database migrations are forward-only; rollback warns before activating code whose recorded migration set is older or unknown.

packages/void/package.json

@@ -90,6 +90,11 @@
     "./routes": {
       "types": "./dist/routes-stub.d.mts"
     },
+    "./nitro": {
+      "types": "./dist/nitro.d.mts",
+      "import": "./dist/nitro.mjs",
+      "require": "./dist/nitro.mjs"
+    },
     "./sveltekit": {
       "types": "./dist/sveltekit.d.mts",
       "import": "./dist/sveltekit.mjs",

packages/void/src/cli/init.ts

@@ -2373,16 +2373,34 @@ function noteManualFrameworkConfigSetup(framework: DetectedFramework): void {
   if (framework.name === 'nuxt') {
     note(
       `Detected Nuxt. Void init does not patch nuxt.config.* automatically.\n\n` +
-        `Add \`voidPlugin()\` to the Nuxt Vite plugins option:\n\n` +
+        `Add \`voidPlugin()\` to the Nuxt Vite plugins option and \`void/nitro\` to the Nitro modules:\n\n` +
         `import { voidPlugin } from "void";\n\n` +
         `export default defineNuxtConfig({\n` +
+        `  nitro: { modules: ["void/nitro"] },\n` +
         `  vite: { plugins: [voidPlugin()] },\n` +
         `});`,
       'Manual Nuxt config step',
     );
     return;
   }
 
+  if (framework.name === 'analog') {
+    note(
+      `Detected Analog. Void init does not patch vite.config.* automatically.\n\n` +
+        `Add \`voidPlugin()\` to the Vite plugins and \`void/nitro\` to Analog's Nitro modules:\n\n` +
+        `import analog from "@analogjs/platform";\n` +
+        `import { voidPlugin } from "void";\n\n` +
+        `export default defineConfig({\n` +
+        `  plugins: [\n` +
+        `    analog({ nitro: { modules: ["nitro-cloudflare-dev", "void/nitro"] } }),\n` +
+        `    voidPlugin(),\n` +
+        `  ],\n` +
+        `});`,
+      'Manual Analog config step',
+    );
+    return;
+  }
+
   noteManualViteConfigSetup();
 }