void 0.20.3 → 0.21.1

package/skills/void/docs/integrations/frameworks/analog.md

@@ -40,6 +40,7 @@ export default defineConfig({
       ssr: true,
       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.
@@ -53,16 +54,20 @@ export default defineConfig({
 });
 ```
 
-### 4. Create `wrangler.jsonc`
+### 4. Create `void.config.ts`
 
-`voidPlugin()` auto-syncs inferred bindings into this file on dev startup:
+Void generates the Cloudflare config used by Analog's development runtime:
 
-```jsonc
-{
-  "name": "my-app",
-  "compatibility_date": "2026-02-24",
-  "compatibility_flags": ["nodejs_compat", "nodejs_als"],
-}
+```ts
+import { defineConfig } from 'void/config';
+
+export default defineConfig({
+  cloudflare: {
+    name: 'my-app',
+    compatibility_date: '2026-02-24',
+    compatibility_flags: ['nodejs_compat', 'nodejs_als'],
+  },
+});
 ```
 
 `nodejs_compat` is required for Nitro's Cloudflare runtime. `nodejs_als` is required for `void/*` runtime helpers (e.g. `void/db`, `void/kv`).
@@ -127,7 +132,7 @@ import { eventHandler } from 'h3';
 import { ai } from 'void/ai';
 
 export default eventHandler(async () => {
-  return ai.run('@cf/meta/llama-3.1-8b-instruct', {
+  return ai.run('@cf/meta/llama-3.3-70b-instruct-fp8-fast', {
     prompt: 'Summarize the latest news',
   });
 });

package/skills/void/docs/integrations/frameworks/astro.md

@@ -35,23 +35,27 @@ import cloudflare from '@astrojs/cloudflare';
 import { voidPlugin } from 'void';
 
 export default defineConfig({
-  adapter: cloudflare(),
+  adapter: cloudflare({ configPath: './.void-wrangler.jsonc' }),
   vite: { plugins: [voidPlugin()] },
 });
 ```
 
 By default, Astro's Cloudflare runtime and `voidPlugin()` migrations share local state at `.wrangler/state/v3`, so no extra persistence configuration is required.
 
-### 4. Create `wrangler.jsonc`
+### 4. Create `void.config.ts`
 
-`voidPlugin()` auto-syncs inferred bindings into this file on dev startup:
+Void uses this config for the Cloudflare adapter during development and deployment:
 
-```jsonc
-{
-  "name": "my-app",
-  "compatibility_date": "2026-02-24",
-  "compatibility_flags": ["nodejs_als"],
-}
+```ts
+import { defineConfig } from 'void/config';
+
+export default defineConfig({
+  cloudflare: {
+    name: 'my-app',
+    compatibility_date: '2026-02-24',
+    compatibility_flags: ['nodejs_als'],
+  },
+});
 ```
 
 `nodejs_als` is required for `void/*` runtime helpers (for example `void/db`, `void/kv`) in Astro.
@@ -126,7 +130,7 @@ import type { APIRoute } from 'astro';
 import { ai } from 'void/ai';
 
 export const POST: APIRoute = async () => {
-  const result = await ai.run('@cf/meta/llama-3.1-8b-instruct', {
+  const result = await ai.run('@cf/meta/llama-3.3-70b-instruct-fp8-fast', {
     prompt: 'Summarize the latest news',
   });
   return Response.json(result);

package/skills/void/docs/integrations/frameworks/nuxt.md

@@ -32,6 +32,7 @@ import { voidPlugin } from 'void';
 export default defineNuxtConfig({
   nitro: {
     preset: 'cloudflare-module',
+    cloudflareDev: { configPath: './.void-wrangler.jsonc' },
     alias: {
       // Nitro has its own bundler that doesn't use Vite aliases.
       // Duplicate @schema here so Nitro can resolve it.
@@ -44,16 +45,20 @@ export default defineNuxtConfig({
 
 By default, Nuxt's Cloudflare development runtime and `voidPlugin()` migrations share local state at `.wrangler/state/v3`, so no extra persistence configuration is required.
 
-### 4. Create `wrangler.jsonc`
+### 4. Create `void.config.ts`
 
-`voidPlugin()` auto-syncs inferred bindings into this file on dev startup:
+Void generates the Cloudflare config used by Nuxt's development runtime:
 
-```jsonc
-{
-  "name": "my-app",
-  "compatibility_date": "2026-02-24",
-  "compatibility_flags": ["nodejs_compat", "nodejs_als"],
-}
+```ts
+import { defineConfig } from 'void/config';
+
+export default defineConfig({
+  cloudflare: {
+    name: 'my-app',
+    compatibility_date: '2026-02-24',
+    compatibility_flags: ['nodejs_compat', 'nodejs_als'],
+  },
+});
 ```
 
 ### 5. Deploy
@@ -111,7 +116,7 @@ export default defineEventHandler(async () => {
 import { ai } from 'void/ai';
 
 export default defineEventHandler(async () => {
-  return ai.run('@cf/meta/llama-3.1-8b-instruct', {
+  return ai.run('@cf/meta/llama-3.3-70b-instruct-fp8-fast', {
     prompt: 'Summarize the latest news',
   });
 });

package/skills/void/docs/integrations/frameworks/overview.md

@@ -45,29 +45,32 @@ With `voidPlugin()` added to the framework's Vite config, frameworks get most of
 - **Auth:** Void-managed auth is not supported in framework mode yet. For now, use Better Auth's official integration for your framework.
 - **Cron jobs:** scheduled handlers via the `crons/` directory.
 - **Queue consumers:** typed producers and consumers via the `queues/` directory.
-- **Revalidation and prerendering:** configure them with [`routing.revalidate`](../../guide/edge/revalidation.md) and [`routing.prerender`](../../guide/edge/prerendering.md) in `void.json`. Void apps can also set these per page in component files.
+- **Revalidation and prerendering:** configure them with [`routing.revalidate`](../../guide/edge/revalidation.md) and [`routing.prerender`](../../guide/edge/prerendering.md) in `void.config.ts`. Void apps can also set these per page in component files.
+
+For framework apps, Void revalidation caches public HTML document responses with both `void deploy` and `void deploy --platform cloudflare`. Client data requests continue to use the framework's own behavior. A response with `Set-Cookie` or `Cache-Control: private`, `no-store`, or `no-cache` is never shared.
 
 Frameworks can also access bindings directly via the framework's own mechanisms (e.g. `platform.env` in SvelteKit, `event.context.cloudflare.env` in Nuxt, `env` from `cloudflare:workers` in Analog, `Astro.locals.runtime.env` in Astro).
 
 ## Configuration
 
-### `void.json`
+### `void.config.ts`
+
+Most configuration is inferred automatically. Use `void.config.ts` to override defaults or fine-tune behavior:
 
-Most configuration is inferred automatically. Use `void.json` to override defaults or fine-tune behavior:
+```ts
+import { defineConfig } from 'void/config';
 
-```json
-{
-  "$schema": "./node_modules/void/schema.json",
-  "inference": {
-    "build": "nuxt build",
-    "scanDirs": ["src", "server", "lib"],
-    "bindings": { "db": "MY_DB" }
+export default defineConfig({
+  inference: {
+    build: 'nuxt build',
+    scanDirs: ['src', 'server', 'lib'],
+    bindings: { db: 'MY_DB' },
+  },
+  routing: {
+    prerender: ['/', '/about', '/pricing'],
+    revalidate: 60,
   },
-  "routing": {
-    "prerender": ["/", "/about", "/pricing"],
-    "revalidate": 60
-  }
-}
+});
 ```
 
 | Field                | Purpose                                                                                                                                                       |
@@ -81,22 +84,25 @@ Most configuration is inferred automatically. Use `void.json` to override defaul
 
 See [Configuration](../../reference/config.md) for the full reference.
 
-### `wrangler.jsonc`
+### Cloudflare settings
 
-Frameworks that use Cloudflare's dev runtime for local dev (SvelteKit, Nuxt with `nitro-cloudflare-dev`, Astro) need a `wrangler.jsonc` for binding configuration. `voidPlugin()` auto-syncs inferred bindings into this file on dev startup:
+Frameworks that use Cloudflare's dev runtime need their adapters pointed at Void's generated `.void-wrangler.jsonc`. Their setup guides show the adapter options. Define your Cloudflare settings in `void.config.ts`:
 
-```jsonc
-{
-  "name": "my-app",
-  "compatibility_date": "2026-02-24",
-  "compatibility_flags": ["nodejs_compat"],
-  // Bindings below are auto-managed by voidPlugin()
-}
+```ts
+import { defineConfig } from 'void/config';
+
+export default defineConfig({
+  cloudflare: {
+    name: 'my-app',
+    compatibility_date: '2026-02-24',
+    compatibility_flags: ['nodejs_compat'],
+  },
+});
 ```
 
-Existing bindings are preserved. Only missing ones are added with local placeholder IDs.
+Existing bindings are preserved. D1, KV, and R2 use local placeholder IDs until deployment. For a project connected directly to Cloudflare, importing `void/ai` adds a remote Workers AI binding during development; [Cloudflare login](../../guide/ai.md#local-development) is required to use it. Direct deployments also include the inferred AI binding.
 
-For `void deploy`, compatibility settings are read from `wrangler.jsonc` automatically (no need to duplicate them in `void.json`).
+Void combines these settings with inferred bindings and records provisioned resource IDs in `void.lock.json`. Commit both files.
 
 ## Deploy Pipeline
 
@@ -109,7 +115,7 @@ void deploy
   │    Reads package.json → determines framework + output conventions
   │
   ├─ 2. Build
-  │    Runs framework's build command (or void.json `build` override)
+  │    Runs framework's build command (or void.config.ts `build` override)
   │    SvelteKit: vite build → .svelte-kit/cloudflare/
   │    Nuxt:      nuxt build → .output/
   │    Analog:    vite build → dist/analog/
@@ -117,10 +123,10 @@ void deploy
   │
   ├─ 3. Analyze
   │    ├─ Locate worker entry + static assets from known output paths
-  │    ├─ Infer bindings from source or read from void.json
+  │    ├─ Infer bindings from source or read from void.config.ts
   │    ├─ Collect migrations from db/migrations/*.sql
   │    ├─ Detect cron and queue handlers
-  │    └─ Read wrangler.jsonc compat settings
+  │    └─ Read void.config.ts Cloudflare settings
   │
   ├─ 4. Wrap (if needed)
   │    If crons or queues are configured:

package/skills/void/docs/integrations/frameworks/react-router.md

@@ -87,7 +87,7 @@ export async function loader() {
 import { ai } from 'void/ai';
 
 export async function action() {
-  return ai.run('@cf/meta/llama-3.1-8b-instruct', {
+  return ai.run('@cf/meta/llama-3.3-70b-instruct-fp8-fast', {
     prompt: 'Summarize the latest news',
   });
 }

package/skills/void/docs/integrations/frameworks/sveltekit.md

@@ -21,53 +21,56 @@ cd my-app
 npm install -D @sveltejs/adapter-cloudflare void
 ```
 
-### 3. Configure `svelte.config.js`
-
-```js
-import adapter from '@sveltejs/adapter-cloudflare';
-import { withVoidTSConfig } from 'void/sveltekit';
-
-export default {
-  kit: {
-    adapter: adapter(),
-    typescript: {
-      config: withVoidTSConfig(),
-    },
-  },
-};
-```
-
-### 4. Add `voidPlugin()` to `vite.config.ts`
+### 3. Configure `vite.config.ts`
 
 ```ts
+import adapter from '@sveltejs/adapter-cloudflare';
 import { sveltekit } from '@sveltejs/kit/vite';
 import { voidPlugin } from 'void';
+import { withVoidTSConfig } from 'void/sveltekit';
 import { defineConfig } from 'vite';
 
 export default defineConfig({
-  plugins: [voidPlugin(), sveltekit()],
+  plugins: [
+    voidPlugin(),
+    sveltekit({
+      adapter: adapter({
+        config: './.void-wrangler.jsonc',
+        platformProxy: { configPath: './.void-wrangler.jsonc' },
+      }),
+      typescript: {
+        config: withVoidTSConfig(),
+      },
+    }),
+  ],
 });
 ```
 
-### 5. Create `wrangler.jsonc`
+If your project already configures SvelteKit in `svelte.config.js`, keep that file and add `typescript.config: withVoidTSConfig()` under its `kit` options instead. SvelteKit ignores `svelte.config.js` when options are passed directly to `sveltekit()`.
 
-SvelteKit's adapter reads bindings from `wrangler.jsonc` for local dev. `voidPlugin()` auto-syncs inferred bindings into this file on dev startup, so you only need the base config:
+### 4. Create `void.config.ts`
 
-```jsonc
-{
-  "name": "my-app",
-  "compatibility_date": "2026-02-24",
-  "compatibility_flags": ["nodejs_compat"],
-}
+Point SvelteKit's adapter at Void's generated Cloudflare config as shown above. Add your Cloudflare settings to `void.config.ts`:
+
+```ts
+import { defineConfig } from 'void/config';
+
+export default defineConfig({
+  cloudflare: {
+    name: 'my-app',
+    compatibility_date: '2026-02-24',
+    compatibility_flags: ['nodejs_compat'],
+  },
+});
 ```
 
 By default, SvelteKit's Cloudflare adapter, `voidPlugin()` migrations, and `void db` commands share local state at `.wrangler/state/v3`, so no extra `platformProxy.persist` configuration is required.
 
-### 6. Configure `tsconfig.json`
+### 5. Configure `tsconfig.json`
 
 SvelteKit generates `.svelte-kit/tsconfig.json` and expects your root config to extend it. Void generates `.void/tsconfig.json` for project-specific aliases such as `void/db` and `@schema`.
 
-Do not add Void's `compilerOptions.paths` to the root `tsconfig.json`; SvelteKit warns because root-level paths override its generated aliases. The `withVoidTSConfig()` hook above merges Void's generated files and aliases into SvelteKit's generated config instead.
+Do not add Void's `compilerOptions.paths` to the root `tsconfig.json`; SvelteKit warns because root-level paths override its generated aliases. The `withVoidTSConfig()` hook merges Void's generated files and aliases into SvelteKit's generated config instead.
 
 ```json
 {
@@ -80,7 +83,7 @@ Do not add Void's `compilerOptions.paths` to the root `tsconfig.json`; SvelteKit
 
 Run `void prepare` after a fresh clone or before typechecking in CI so `.void/tsconfig.json` exists before SvelteKit syncs its config.
 
-### 7. Deploy
+### 6. Deploy
 
 ```bash
 void auth login
@@ -132,7 +135,7 @@ import { ai } from 'void/ai';
 
 export const actions = {
   summarize: async () => {
-    return ai.run('@cf/meta/llama-3.1-8b-instruct', {
+    return ai.run('@cf/meta/llama-3.3-70b-instruct-fp8-fast', {
       prompt: 'Summarize the latest news',
     });
   },

package/skills/void/docs/integrations/frameworks/tanstack-start.md

@@ -92,7 +92,7 @@ import { createServerFn } from '@tanstack/react-start';
 import { ai } from 'void/ai';
 
 const summarize = createServerFn().handler(async () => {
-  return ai.run('@cf/meta/llama-3.1-8b-instruct', {
+  return ai.run('@cf/meta/llama-3.3-70b-instruct-fp8-fast', {
     prompt: 'Summarize the latest news',
   });
 });

package/skills/void/docs/integrations/nodejs-bun-deno.md

@@ -4,7 +4,7 @@ outline: deep
 
 # Node.js, Bun, and Deno
 
-Set `target` in `void.json` to build for Node.js, Bun, or Deno. You can run the resulting server on your own machine, in a container, or with a hosting provider.
+Set `target` in `void.config.ts` to build for Node.js, Bun, or Deno. You can run the resulting server on your own machine, in a container, or with a hosting provider.
 
 ```json
 { "target": "node" }
@@ -25,7 +25,7 @@ All three produce the same project structure and use the same Hono-based routing
 ### 1. Configure the target
 
 ```json
-// void.json
+// void.config.ts
 { "target": "node" }
 ```
 
@@ -140,7 +140,7 @@ Inbound [email handlers](../guide/email.md#inbound) in `email/` need Cloudflare
 
 ### Ignored config fields
 
-Void warns and ignores these Cloudflare-specific `void.json` fields on other targets:
+Void warns and ignores these Cloudflare-specific `void.config.ts` fields on other targets:
 
 - `inference.bindings`: Cloudflare binding configuration
 - `remote`: remote binding proxy
@@ -166,11 +166,11 @@ my-app/
       hello.ts
   package.json
   vite.config.ts
-  void.json
+  void.config.ts
 ```
 
 ```json
-// void.json
+// void.config.ts
 { "target": "node" }
 ```
 

package/skills/void/docs/reference/api.md

@@ -10,7 +10,7 @@ This page is the source of truth for user-facing `void` exports. Use it when you
 
 ### `voidPlugin(options?)`
 
-Named export from `"void"`. Returns an array of Vite plugins that set up file-based routing, migration support, and the Cloudflare Workers runtime. Application-level configuration is read from [`void.json`](./config.md); the optional `options` object controls Vite/Cloudflare plugin behavior.
+Named export from `"void"`. Returns an array of Vite plugins that set up file-based routing, migration support, and the Cloudflare Workers runtime. Application-level configuration is read from [`void.config.ts`](./config.md); the optional `options` object controls Vite/Cloudflare plugin behavior.
 
 ```ts
 import { voidPlugin } from 'void';
@@ -25,6 +25,23 @@ export default defineConfig({
 | `persistTo`        | `string`                  | Directory path for persisting local dev state (D1, KV, R2). Defaults to `.void/` in the project root.                                                                                                                             |
 | `auxiliaryWorkers` | `AuxiliaryWorkerConfig[]` | Additional workers to run inside the same Miniflare instance during dev. Passed through to `@cloudflare/vite-plugin`. Useful for running multiple workers that share bindings (e.g. a separate API worker alongside a dashboard). |
 
+## Project configuration
+
+### `defineConfig(config)`
+
+Import from `void/config` in the root `void.config.ts`. It returns the config with editor completion and TypeScript checking. Void validates the result when loading it, including values computed at runtime.
+
+```ts
+import { defineConfig } from 'void/config';
+
+export default defineConfig({
+  cloudflare: { name: 'my-app' },
+  routing: { revalidate: 60 },
+});
+```
+
+See the [config reference](./config.md) for all fields.
+
 ## Handlers
 
 Imported from `"void"` or `"void/handler"`.
@@ -278,7 +295,7 @@ function defineHead<P = Record<string, unknown>>(
 
 ## Rewrites
 
-URL rewrites re-dispatch a request at a different internal path without changing the browser's URL. `c.rewrite()`, `c.originalUrl()`, and `c.isRewritten()` are available on every Hono `Context` the Void runtime hands you. See the [Rewrites guide](../guide/edge/rewrites.md) for the full overview, including static `routing.rewrites` / `routing.fallbacks` in [`void.json`](./config.md#routing).
+URL rewrites re-dispatch a request at a different internal path without changing the browser's URL. `c.rewrite()`, `c.originalUrl()`, and `c.isRewritten()` are available on every Hono `Context` the Void runtime hands you. See the [Rewrites guide](../guide/edge/rewrites.md) for the full overview, including static `routing.rewrites` / `routing.fallbacks` in [`void.config.ts`](./config.md#routing).
 
 ### `c.rewrite(destination)`
 
@@ -345,7 +362,7 @@ import type { RewriteDestination } from 'void/routes';
 Union of the exact route patterns from your generated `RouteMap` plus a `string` fallback (`RouteName | (string & {})`). Known route patterns (e.g. `/posts/[id]`) are offered as autocomplete entries in your editor, while the `string` branch keeps the type assignable from concrete runtime paths like `` `/posts/${id}` `` — there is no `:id` template-literal resolution at the type level. Used as:
 
 - The parameter type of [`c.rewrite()`](#c-rewrite-destination).
-- The type of `destination` entries in `routing.rewrites` and `routing.fallbacks` in [`void.json`](./config.md#routing).
+- The type of `destination` entries in `routing.rewrites` and `routing.fallbacks` in [`void.config.ts`](./config.md#routing).
 
 Like [`RouteMap`](#routemap), `RewriteDestination` lives in the virtual `void/routes` module and is refreshed whenever routes change.
 
@@ -752,7 +769,7 @@ Typed AI client for Cloudflare AI models and provider-native AI Gateway requests
 ```ts
 import { ai } from 'void/ai';
 
-const result = await ai.run('@cf/meta/llama-3.1-8b-instruct', {
+const result = await ai.run('@cf/meta/llama-3.3-70b-instruct-fp8-fast', {
   messages: [{ role: 'user', content: 'Summarize this release note.' }],
 });