void 0.10.12 → 0.20.0

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

@@ -8,7 +8,7 @@ outline: deep
 
 Use this page as the exact reference for `void.json`. If you are still learning how the pieces fit together, start in the guide first and come back here when you need field-by-field details.
 
-Project-level configuration lives in a `void.json` file at the project root. Most fields are optional. Cloudflare-targeted apps must pin a Workers `compatibility_date` in `worker.compatibility_date` or in a supported wrangler fallback file (`wrangler.jsonc` or `wrangler.json`). If no date is configured, Void writes the latest known-good date to `void.json` so future runs stay explicit and stable.
+Project-level configuration lives in a `void.json` file at the project root. Most fields are optional. Cloudflare-targeted apps must pin a Workers `compatibility_date` in `worker.compatibility_date` or in a supported Cloudflare fallback file (`wrangler.jsonc` or `wrangler.json`). If no date is configured, Void writes the latest known-good date to `void.json` so future runs stay explicit and stable.
 
 ```json
 {
@@ -53,7 +53,7 @@ When set, those conventions move under the configured directory:
 { "sourceDir": "src" }
 ```
 
-With that config, Void reads `src/pages`, `src/routes`, `src/db/schema.ts`, `src/db/migrations`, `src/auth.ts`, and `src/env.ts`. Project files such as `void.json`, `vite.config.ts`, `package.json`, `tsconfig.json`, `wrangler.json`, `public/`, and `.env*` stay at the project root. Void does not scan both locations; if source conventions exist in both places during dev/build, remove one copy so the active source tree is unambiguous.
+With that config, Void reads `src/pages`, `src/routes`, `src/db/schema.ts`, `src/db/migrations`, `src/auth.ts`, and `src/env.ts`. Project files such as `void.json`, `vite.config.ts`, `package.json`, `tsconfig.json`, `wrangler.json`, `public/`, and the local-only `.env` stay at the project root. Void does not scan both locations; if source conventions exist in both places during dev/build, remove one copy so the active source tree is unambiguous.
 
 ### `auth`
 
@@ -111,7 +111,7 @@ Supported values for `auth.providers`:
 
 ### `database`
 
-Database backend. Omit for D1/SQLite (default). Set to `"pg"` for PostgreSQL via Hyperdrive.
+Database backend. Omit for D1/SQLite (default). Set to `"pg"` or `"mysql"` for an external database through Hyperdrive.
 
 ```json
 {
@@ -123,13 +123,36 @@ Database backend. Omit for D1/SQLite (default). Set to `"pg"` for PostgreSQL via
 | ----------- | ------------------------------------------------------- |
 | _(omitted)_ | D1 (SQLite), fully managed by Void with no extra config |
 | `"pg"`      | PostgreSQL via Hyperdrive; bring your own database      |
+| `"mysql"`   | MySQL via Hyperdrive; bring your own database           |
 
-When using `"pg"`:
+When using an external database:
 
-- Add `DATABASE_URL` to `.env.local` for local development
-- Import schema helpers from `void/schema-pg` instead of `void/schema-d1`
+- Add `DATABASE_URL` to `.env` for local development
+- Import schema helpers from `void/schema-pg` or `void/schema-mysql`
 - `void/db` connects via Hyperdrive in production, direct connection locally
-- `void gen model` generates `pgTable` with `serial`, `timestamp`, etc.
+- `void gen model` generates dialect-appropriate table and column builders
+
+### `email`
+
+Configuration for the [email integration](../guide/email.md).
+
+```json
+{
+  "email": {
+    "from": "Acme <noreply@mail.acme.com>"
+  }
+}
+```
+
+| Field  | Type     | Description                                                                                                    |
+| ------ | -------- | -------------------------------------------------------------------------------------------------------------- |
+| `from` | `string` | Default sender for `sendEmail()`: one address, optionally with a display name (`Acme <noreply@mail.acme.com>`) |
+
+What `from` does depends on where the app runs:
+
+- **`void dev`** — becomes the default `from` of every `sendEmail()` call, captured in the dev inbox; no mail leaves the machine.
+- **`void deploy`** (managed platform) — not used: the sender is pinned to your project's own platform address, which Void fills in for you.
+- **`void deploy --platform cloudflare`** (your own Cloudflare account) — the address host (`mail.acme.com`) is the domain Void sets Email Routing and Email Sending up on, and the address becomes the default `from` (written into the worker as the `__VOID_EMAIL_FROM` var). The host must be a zone in the pinned Cloudflare account, or a subdomain of one; a subdomain is the usual choice, and the apex is refused when it already receives mail elsewhere. An app that uses email without `email.from` deploys without it and prints the line to add. Void never picks a zone or writes `void.json` for you. See [Your own Cloudflare account](../guide/email.md#your-own-cloudflare-account).
 
 ### `head`
 
@@ -168,9 +191,9 @@ Output mode. Controls the default rendering strategy for pages.
 | Value                | Default prerender | Per-page override                | Prerender timing           |
 | -------------------- | ----------------- | -------------------------------- | -------------------------- |
 | `"server"` (default) | `false`           | `export const prerender = true`  | Deploy-time (platform ISR) |
-| `"static"`           | `true`            | `export const prerender = false` | Build-time (`vite build`)  |
+| `"static"`           | `true`            | `export const prerender = false` | Build or deploy post-build |
 
-When set to `"static"`, all pages are prerendered at build time as static HTML files written to `dist/client/`. Individual pages can opt out with `export const prerender = false`. Dynamic pages (with route params) without a `getPrerenderPaths()` export are implicitly not prerendered.
+When set to `"static"`, all pages are prerendered as static HTML files written to `dist/client/`. A standalone `vite build` renders them in the build; managed `void deploy` renders immediately afterward in the trusted deploy process so build plugins never receive platform credentials. Individual pages can opt out with `export const prerender = false`. Dynamic pages (with route params) without a `getPrerenderPaths()` export are implicitly not prerendered.
 
 When omitted or set to `"server"`, pages are server-rendered on request. Individual pages can opt into deploy-time prerendering with `export const prerender = true`, or opt out of server-rendered component HTML with `export const ssr = false`.
 
@@ -213,18 +236,18 @@ Enable and configure Cloudflare Sandboxes for Void apps. Importing from `void/sa
 }
 ```
 
-| Field               | Type     | Default                                  |
-| ------------------- | -------- | ---------------------------------------- |
-| `binding`           | `string` | `SANDBOX`                                |
-| `className`         | `string` | `Sandbox`                                |
-| `containerName`     | `string` | `void-sandbox`                           |
-| `image`             | `string` | Bundled `@cloudflare/sandbox` Dockerfile |
-| `imageBuildContext` | `string` | Directory of `image`                     |
-| `platformImage`     | `string` | Matching sandbox SDK registry image      |
-| `instanceType`      | `string` | `lite` on Void deploy                    |
-| `maxInstances`      | `number` | `20` on Void deploy                      |
+| Field               | Type     | Default                              |
+| ------------------- | -------- | ------------------------------------ |
+| `binding`           | `string` | `SANDBOX`                            |
+| `className`         | `string` | `Sandbox`                            |
+| `containerName`     | `string` | `void-sandbox`                       |
+| `image`             | `string` | Matching published sandbox SDK image |
+| `imageBuildContext` | `string` | Directory of `image`                 |
+| `platformImage`     | `string` | Matching sandbox SDK registry image  |
+| `instanceType`      | `string` | `lite` on Void deploy                |
+| `maxInstances`      | `number` | `20` on Void deploy                  |
 
-Sandbox support currently applies to Void apps on the Cloudflare target. `void deploy` supports registry images. If `sandbox.image` is a custom local Dockerfile path, set `sandbox.platformImage` to the pushed image that the platform should run.
+Sandbox support currently applies to Void apps on the Cloudflare target. Native deployment requires [Workers Paid](https://dash.cloudflare.com/?to=/:account/workers/plans) because Cloudflare Containers are unavailable on Workers Free. `void deploy --platform cloudflare` verifies Containers access before provisioning resources or building the app and explains how to fix a missing plan or API-token permission. Apps that do not import `void/sandbox` or configure `sandbox` emit no Container and perform no entitlement check. The default registry image is pinned to the installed `@cloudflare/sandbox` version, so local and native Cloudflare deploys run the same container as Void Platform. If `sandbox.image` is a custom local Dockerfile path, set `sandbox.platformImage` to the pushed image that the platform should run.
 
 ### `target`
 
@@ -247,13 +270,14 @@ Void-managed WebSocket route files (`*.ws.ts`) are Cloudflare-only because they
 
 ### `worker`
 
-Curated Cloudflare Workers configuration. Cloudflare-targeted apps require an explicit `compatibility_date` here unless it is provided by a supported wrangler fallback file. If no date is configured, Void writes the latest known-good date here. Binding arrays such as `d1_databases`, `kv_namespaces`, and `r2_buckets` are not allowed here because Void manages bindings through inference and `inference.bindings`. If you need custom bindings with real IDs, use a `wrangler.json` and `wrangler deploy`.
+Curated Cloudflare Workers configuration. Cloudflare-targeted apps require an explicit `compatibility_date` here unless it is provided by a supported Cloudflare fallback file. If no date is configured, Void writes the latest known-good date here. Binding arrays such as `d1_databases`, `kv_namespaces`, and `r2_buckets` are not allowed here because Void manages bindings through inference and `inference.bindings`. If you need custom bindings with real IDs, add them to `wrangler.jsonc`; Void preserves them during deployment.
 
 | Field                 | Type       | Description                            |
 | --------------------- | ---------- | -------------------------------------- |
 | `compatibility_date`  | `string`   | Cloudflare Workers compatibility date  |
 | `compatibility_flags` | `string[]` | Cloudflare Workers compatibility flags |
 | `vars`                | `object`   | Plain-text worker variables            |
+| `limits`              | `object`   | Worker resource limit overrides        |
 
 ```json
 {
@@ -267,7 +291,19 @@ Curated Cloudflare Workers configuration. Cloudflare-targeted apps require an ex
 }
 ```
 
-`worker.vars` values must be strings. They are merged into Worker bindings before `.env` files are loaded, so project `.env` values override `worker.vars` for local dev/build. Do not put secrets here; use `env.ts` plus `void secret put` for production secrets.
+`worker.vars` values must be strings. Root `.env` values override them during local development only. Production builds do not load `.env`, and reject any `worker.vars` name declared as a server key in `env.ts`. Use `void secret put` for production server values.
+
+`worker.limits.cpu_ms` caps Workers CPU time per request, in milliseconds. It must be an integer between 1 and 300000 (Cloudflare's hard maximum, 5 minutes). A deploy that requests more than your account plan's ceiling fails with an error naming both the requested value and the plan maximum. Only a rollback clamps: rolling back to a deployment whose configured limit now exceeds your plan applies the plan ceiling instead of failing. If your plan changes so that a previously valid value now exceeds the ceiling, deploys keep failing until you lower `cpu_ms` in `void.json`. On the direct Cloudflare path, the value is written into the generated `dist/ssr/wrangler.json` as `limits.cpu_ms` and enforced by Cloudflare directly. The Void plan ceiling does not apply there, but your Cloudflare account's own CPU-time allowance still does: the Workers Free plan caps CPU at 10 ms per request, and the Workers Paid plan allows up to 300000 ms. A value above what your Cloudflare account permits is constrained or rejected by Cloudflare, not by Void.
+
+```json
+{
+  "worker": {
+    "limits": {
+      "cpu_ms": 30000
+    }
+  }
+}
+```
 
 ### `routing`
 
@@ -334,6 +370,20 @@ Fallback rewrites. Same shape as `rewrites`, but rules only fire when no static
 }
 ```
 
+#### `routing.isr`
+
+Boolean switch for Void's ISR caching. When omitted or `true`, Void infers caching from your revalidate and prerender settings. Setting it to `false` disables ISR and edge prerendering for the whole app, including per-page exports:
+
+```json
+{
+  "routing": {
+    "isr": false
+  }
+}
+```
+
+This does not disable `output: "static"` build-time HTML generation or delete existing KV resources. Set it to `true` to enable your configured cache policies again. Existing-Worker migration saves this choice before provisioning, so it remains consistent on retries and later deployments.
+
 #### `routing.revalidate`
 
 ISR revalidation TTL in seconds, either globally or per path. See [Revalidation](../guide/edge/revalidation.md) for details.
@@ -396,6 +446,8 @@ Set `"404-page"` when your assets come from a static site generator (VitePress,
 
 This does **not** apply to SvelteKit, Nuxt, Analog, or Astro deploys: those pin `not_found_handling` to `"none"` because the framework's own worker owns unmatched HTML, and `void deploy` warns if you set `routing.notFound` anyway.
 
+TanStack Start, React Router, and vinext honor it on a managed `void deploy`, which resolves the asset config itself. Void writes no `assets` policy into their generated Worker config (`dist/server` for TanStack Start and vinext App, `build/server` for React Router, `dist/ssr` for vinext Pages). A custom config must declare a complete `assets` policy — `binding`, `directory`, `not_found_handling`, and `run_worker_first`. Void leaves those fields untouched, so your own policy is honored; with none, Cloudflare's default applies. `vite build` warns when it is set. See [Static Assets](../guide/edge/static-assets.md#unmatched-requests) for the per-framework paths.
+
 ### `inference`
 
 Configuration for build-time inference, including how Void detects your app type, bindings, and build process.
@@ -407,7 +459,7 @@ Explicitly control inferred Cloudflare bindings. If omitted, bindings are [autom
 Each binding accepts `true` (use default name), `false` (disable), or a string (custom binding name):
 
 ```json
-{ "inference": { "bindings": { "db": true, "kv": false, "storage": "MY_BUCKET" } } }
+{ "inference": { "bindings": { "db": true, "kv": false, "storage": "MY_BUCKET", "ai": "MY_AI" } } }
 ```
 
 | Key       | Default Binding | Type          | Custom Name              |
@@ -415,9 +467,12 @@ Each binding accepts `true` (use default name), `false` (disable), or a string (
 | `db`      | `DB`            | `D1Database`  | `"db": "MY_DB"`          |
 | `kv`      | `KV`            | `KVNamespace` | `"kv": "MY_KV"`          |
 | `storage` | `STORAGE`       | `R2Bucket`    | `"storage": "MY_BUCKET"` |
-| `ai`      | `AI`            | `Ai`          | Boolean only             |
+| `ai`      | `AI`            | `Ai`          | `"ai": "MY_AI"`          |
+| `email`   | —               | —             | Boolean only             |
+
+Custom resource binding names flow through deploy manifests, Cloudflare config generation, remote binding proxying, internal migrations, and generated runtime helpers such as `void/db`, `void/kv`, and `void/storage`. Custom AI names apply to generated Cloudflare configuration and `void/ai` runtime resolution for direct Cloudflare builds; managed Workers AI continues to use Void's service proxy.
 
-Custom names are used in the deploy manifest, Wrangler config generation/sync, remote binding proxying, internal migrations, and generated runtime helpers such as `void/db`, `void/kv`, and `void/storage`.
+`email` is a feature switch rather than a Cloudflare binding, so it has no binding name or type. On the platform, outbound mail is sent through the Void proxy, which owns the `send_email` binding — none is written into your worker; on your own Cloudflare account, `void deploy --platform cloudflare` writes a `send_email` binding named `SEND_EMAIL` into `wrangler.jsonc` itself once email is set up (see [`email.from`](#email)). Set it to `true` to turn the [email integration](../guide/email.md) on — which registers the `void dev` inbox — even when no scanned file imports `void/email`, or `false` to turn it off.
 
 #### `inference.build`
 

package/skills/void/docs/reference/resource-inference.md

@@ -18,18 +18,21 @@ This runs once before plugins initialize, so the results are available to config
 
 ## Detected Bindings
 
-| Binding   | Type                              | Detected by import                                                                                                                                               | Detected by env access           |
-| --------- | --------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------- |
-| `DB`      | `D1Database`                      | `import { db } from "void/db"`                                                                                                                                   | `env.DB` or `c.env.DB`           |
-| `KV`      | `KVNamespace`                     | `import { kv } from "void/kv"`                                                                                                                                   | `env.KV` or `c.env.KV`           |
-| `STORAGE` | `R2Bucket`                        | `import { storage } from "void/storage"`                                                                                                                         | `env.STORAGE` or `c.env.STORAGE` |
-| `AI`      | `Ai`                              | `import { ai } from "void/ai"`                                                                                                                                   | `env.AI` or `c.env.AI`           |
-| `SANDBOX` | `DurableObjectNamespace<Sandbox>` | `import { getSandbox } from "void/sandbox"`                                                                                                                      | `env.SANDBOX` or `c.env.SANDBOX` |
-| Auth      | none                              | `import { ... } from "void/auth"` or `import { auth } from "void/client"` / `void/client/react` / `void/client/vue` / `void/client/svelte` / `void/client/solid` | none                             |
-| `QUEUE_*` | `Queue`                           | `import { queues } from "void/queues"`                                                                                                                           | `env.QUEUE_*`                    |
+| Binding          | Type                              | Detected by import                                                                                                                                               | Detected by env access           |
+| ---------------- | --------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------- |
+| `DB`             | `D1Database`                      | `import { db } from "void/db"`                                                                                                                                   | `env.DB` or `c.env.DB`           |
+| `KV`             | `KVNamespace`                     | `import { kv } from "void/kv"`                                                                                                                                   | `env.KV` or `c.env.KV`           |
+| `STORAGE`        | `R2Bucket`                        | `import { storage } from "void/storage"`                                                                                                                         | `env.STORAGE` or `c.env.STORAGE` |
+| `AI`             | `Ai`                              | `import { ai } from "void/ai"`                                                                                                                                   | `env.AI` or `c.env.AI`           |
+| `SANDBOX`        | `DurableObjectNamespace<Sandbox>` | `import { getSandbox } from "void/sandbox"`                                                                                                                      | `env.SANDBOX` or `c.env.SANDBOX` |
+| Auth             | none                              | `import { ... } from "void/auth"` or `import { auth } from "void/client"` / `void/client/react` / `void/client/vue` / `void/client/svelte` / `void/client/solid` | none                             |
+| `QUEUE_*`        | `Queue`                           | `import { queues } from "void/queues"`                                                                                                                           | `env.QUEUE_*`                    |
+| filename-derived | `DurableObjectNamespace`          | A default-exported `defineDurableState()` module in `durable-objects/`                                                                                           | n/a                              |
 
 Auth detection also triggers when importing the `auth` specifier from `void/client` or a framework-specific client subpath such as `void/client/react` (but not when importing only `fetch`).
 
+Durable state uses a filesystem convention rather than the import scanner. For example, `durable-objects/shopping-cart.ts` creates the `SHOPPING_CART` binding, exports `ShoppingCartDurableObject`, and adds a `new_sqlite_classes` migration. See [Durable State](../guide/durable-state.md).
+
 ## Scanned Directories
 
 ### Standard mode
@@ -65,6 +68,7 @@ Regardless of mode, these are always checked:
 
 - **SSR entry** such as `src/main.ssr.ts`, for SSR apps that access bindings during rendering
 - **`src/`**, which is always scanned for auth imports unless it is already in the scan list for framework mode
+- **`durable-objects/`**, which is scanned for typed Durable Object state modules in native Void apps
 
 ## Custom Scan Directories
 

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

@@ -80,6 +80,7 @@ File-based HTTP API endpoints built on [Hono](https://hono.dev). Each file expor
 - **Catch-all**: `[...slug]` matches the remaining path
 - **Route groups**: `(admin)/` organizes files without affecting URL paths
 - **Files starting with `_`** are ignored
+- **Environment suffix**: `debug.dev.ts` builds in development only, `metrics.prod.ts` in production only
 
 See [Server Routing](/guide/server-routing) for the full guide.
 
@@ -163,14 +164,12 @@ Generate or refresh it with `void prepare`, or let `vite dev` / `vite build` pop
 
 ## Config Files
 
-| File                    | Purpose                                                                                                                                                  |
-| ----------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `vite.config.ts`        | Vite configuration. Must include `voidPlugin()`.                                                                                                         |
-| `void.json`             | Optional Void config for [routing](/reference/config#routing), [inference](/reference/config#inference), and [worker settings](/reference/config#worker) |
-| `tsconfig.json`         | TypeScript config. Extend `.void/tsconfig.json` for auto-generated types; run `void init --tsconfig` when an existing config already uses `extends`.     |
-| `.env`                  | Public environment variables (committed)                                                                                                                 |
-| `.env.local`            | Secret variables for local dev (gitignored)                                                                                                              |
-| `.env.production`       | Public production variables (committed)                                                                                                                  |
-| `.env.production.local` | Production secrets for local testing (gitignored)                                                                                                        |
-
-See [Environment Variables](/guide/env-vars) for the full env file loading order.
+| File             | Purpose                                                                                                                                                  |
+| ---------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `vite.config.ts` | Vite configuration. Must include `voidPlugin()`.                                                                                                         |
+| `void.json`      | Optional Void config for [routing](/reference/config#routing), [inference](/reference/config#inference), and [worker settings](/reference/config#worker) |
+| `tsconfig.json`  | TypeScript config. Extend `.void/tsconfig.json` for auto-generated types; run `void init --tsconfig` when an existing config already uses `extends`.     |
+| `.env`           | Local development values only (gitignored; never deployed)                                                                                               |
+| `env.ts`         | Checked-in env names, types, defaults, and requiredness                                                                                                  |
+
+See [Environment Variables](/guide/env-vars) for local, production-secret, and client build behavior.

package/AGENT_PROMPT.md

@@ -1,19 +0,0 @@
-## Void
-
-This project uses [Void](https://void.cloud) — a fullstack Vite plugin + deployment platform for Cloudflare. `voidPlugin()` in `vite.config.ts` gives you file-based API routing on Hono (`routes/`), Inertia-inspired server-rendered pages with co-located loaders/actions (`pages/` + `@void/vue` or `@void/react`), auto-provisioned D1/KV/R2 bindings, first-class Drizzle ORM integration (schema in `db/schema.ts` -> `void/db` Drizzle instance -> typed routes -> typed fetch client), built-in auth, queues, cron jobs, edge caching (ISR), and one-command deploys via `npx void deploy`. For first-time setup, prefer `npx void init`; in an empty directory, install `void` first and let the interactive flow scaffold the starter with Vite+ by default, add the matching framework adapter, configure project files, handle auth, and link or create the deploy project before the first deploy. In an existing app, `void init` configures Void in place by adding missing Vite scripts and creating or patching `vite.config.*` with `voidPlugin()`. Use `void` and `@void/*` package names in source code and package manifests.
-
-Database: define Drizzle tables in `db/schema.ts`, import `db` from `void/db` and tables from `@schema`. Use `void db push` for prototyping, `void db generate` for production migrations. `drizzle-orm` and `drizzle-kit` ship with void (no extra install). Migrations live in `db/migrations/`.
-
-Env: declare every env key in `env.ts` at the project root via `defineEnv({ KEY: string(), ... })` from `void/env`. Read values via `import { env } from "void/env"`. Schema validation runs at dev start (warns) and on `void deploy` (hard error on missing prod secrets). Use `VITE_*` prefix for keys that should be exposed to client code.
-
-CI/editor prep: run `void prepare` to generate `.void/routes.d.ts`, `.void/db.d.ts`, `.void/queues.d.ts`, `.void/env.d.ts`, and `.void/tsconfig.json` without booting Vite. Run it after `npm install` in CI or a fresh clone before typechecking; `vite dev` and `vite build` regenerate these during normal workflows.
-
-Rewrites and redirects: declare static rules in `void.json` under `routing.redirects` / `routing.rewrites` / `routing.fallbacks`, or in a `public/_redirects` file. For dynamic rewrites, call `c.rewrite(path)` in a `defineMiddleware`.
-
-Logs: surface app-level errors that should show up under `void project logs --level error` via `import { logger } from "void/log"` and `logger.error(msg, fields?)` (also `.warn` / `.info`). Anything caught and only persisted to your own DB is invisible to Cloudflare Tail; route it through `logger.*` or `console.*` so the platform can see it.
-
-Requests: `void project logs` only has rows when a worker actually ran. 5xx generated by the edge router, and every request to a static/SPA project, produce no log line at all. Use `void project requests --status 5xx --range 12h` to see those — it lists status, method, and duration for every request the edge served, whether or not a worker was invoked.
-
-Self-host deploy: `void deploy` targets the Void platform; to deploy to the user's OWN Cloudflare account instead, use `void deploy --backend cloudflare` (add `--provision` on the first deploy to create the D1/KV/R2/Queues/Hyperdrive resources the source needs). It uses local wrangler auth, so pin an account (`account_id` in `wrangler.jsonc` or `CLOUDFLARE_ACCOUNT_ID`) and keep real secrets in `wrangler secret put` — every `.env*` file this backend loads (`.env`, `.env.local`, `.env.production`, `.env.production.local`) ships as plaintext worker vars, `.local` included. Provisioning a Hyperdrive config reads `DATABASE_URL` from the shell, not from `.env*`. v1 supports full Void apps on the Cloudflare Workers target only (D1/KV/R2/Queues/Hyperdrive; auth and ISR on D1/SQLite); framework SSR of every kind (TanStack Start, React Router, vinext, SvelteKit, Nuxt, Analog, Astro), static/SPA/SSG apps (including `output: "static"`), WebSocket/Durable Object apps (`*.ws.ts`), a custom `migrations_pattern`, node/bun/deno targets, and PostgreSQL apps with auth all fail closed with guidance. Auth apps must ship checked-in migrations that produce the Better Auth schema. `--provision` is a single-operator, dev-machine step and is disabled in CI.
-
-Full docs are in `node_modules/void/docs/`. If you have the `void` skill available, use it for a complete API reference covering project structure, routing, pages mode, database, auth, typed fetch, KV, storage, queues, cron jobs, CLI, configuration, and deployment.

package/dist/cf-access-Bqw81xAf.mjs

@@ -1,22 +0,0 @@
-//#region src/shared/cf-access.ts
-/**
-* Resolve Cloudflare Access headers from an env-like object.
-*
-* Priority:
-*   1. Service token pair (`CF_ACCESS_CLIENT_ID` + `CF_ACCESS_CLIENT_SECRET`) — CI path
-*   2. User JWT (`CF_ACCESS_TOKEN`) — dev path, typically populated via `cloudflared access token`
-*   3. No headers — prod, or unprotected hostnames
-*/
-function cfAccessHeaders(env) {
-	const id = env.CF_ACCESS_CLIENT_ID;
-	const secret = env.CF_ACCESS_CLIENT_SECRET;
-	if (typeof id === "string" && typeof secret === "string" && id.length > 0 && secret.length > 0) return {
-		"CF-Access-Client-Id": id,
-		"CF-Access-Client-Secret": secret
-	};
-	const token = env.CF_ACCESS_TOKEN;
-	if (typeof token === "string" && token.length > 0) return { "cf-access-token": token };
-	return {};
-}
-//#endregion
-export { cfAccessHeaders as t };

package/dist/env-CZy5MorI.mjs

@@ -1,299 +0,0 @@
-import { a as join } from "./dist-DaKKDf8D.mjs";
-import { D as outro, E as note, T as log, a as cliTitle, w as intro } from "./agents-CtgBYqld.mjs";
-import { b as readProjectConfig, f as getToken, n as PlatformClient } from "./client-Gb71-XkG.mjs";
-import { r as generateEnvTypes, t as findEnvFile } from "./env-types-QBj-ndax.mjs";
-import { h as loadUserEnvFile, l as fetchRemoteSecretNames, m as validateProdEnv, u as formatEnvReport } from "./env-validation-Dea3v3ej.mjs";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-//#region src/cli/env-example.ts
-/**
-* `void env example` — generate a `.env.example` block from the registered
-* env schema, managed as a marker-delimited section so any user-managed
-* entries (CI tokens, build flags, etc.) above or below the block survive
-* a refresh.
-*
-* Marker convention mirrors the one used by `init.ts` for CLAUDE.md /
-* AGENTS.md instructions: a literal start marker, a body, and a literal
-* end marker. The markers are hash-prefixed so they remain valid dotenv
-* comments and don't trip up tools that parse `.env` files.
-*
-* Schema introspection strategy:
-*   - Call `schema['~standard'].validate(undefined)`:
-*       • `{ value: undefined }` → optional (no default)
-*       • `{ value: <x> }`       → has a default (value is `<x>`)
-*       • `{ issues: [...] }`    → required
-*   - For enum hints, probe with a sentinel that is unlikely to match and
-*     parse the built-in `oneOf` error message ("Expected one of A, B, got ..."),
-*     yielding the valid values. This only works for Void's built-in
-*     `oneOf()` helper — third-party validators silently degrade to no hint,
-*     which is fine because `.env.example` is purely informational.
-*
-* This keeps the introspection layer Standard Schema-friendly (no private
-* fields, no type-widening) while still giving a good DX for the common
-* Void helpers.
-*/
-/** Load the user's env.ts so `defineEnv` registers the schema. */
-async function loadRegisteredSchema(envFile) {
-	await loadUserEnvFile(envFile);
-	return (await import("./runtime/env-public.mjs"))._getRegisteredSchema();
-}
-/**
-* Introspect a single schema into an {@link EntryKind}.
-*
-* The probing logic is pure: it only calls the public `~standard.validate`
-* contract, so it works for any Standard Schema-compliant validator.
-*/
-function classifySchema(schema) {
-	const enumValues = tryExtractEnumValues(schema);
-	const probe = schema["~standard"].validate(void 0);
-	if (probe instanceof Promise) return {
-		kind: "required",
-		enumValues
-	};
-	if ("issues" in probe && probe.issues) return {
-		kind: "required",
-		enumValues
-	};
-	if (probe.value === void 0) return {
-		kind: "optional",
-		enumValues
-	};
-	return {
-		kind: "default",
-		defaultValue: probe.value,
-		enumValues
-	};
-}
-/**
-* Attempt to pull enum values out of a Void `oneOf()` schema by probing with
-* an invalid sentinel and parsing the error message. Returns undefined for
-* any schema that isn't a built-in `oneOf`.
-*/
-function tryExtractEnumValues(schema) {
-	const result = schema["~standard"].validate("__void_env_example_probe__");
-	if (result instanceof Promise) return;
-	if (!("issues" in result) || !result.issues || result.issues.length === 0) return;
-	const message = result.issues[0].message;
-	const match = /^Expected one of (.+), got "/.exec(message);
-	if (!match) return;
-	return match[1].split(",").map((s) => s.trim());
-}
-/** Serialize a default value into a dotenv-friendly string. */
-function serializeDefault(value) {
-	if (typeof value === "string") return value;
-	if (typeof value === "number" || typeof value === "boolean") return String(value);
-	try {
-		return JSON.stringify(value);
-	} catch {
-		return "";
-	}
-}
-/**
-* Build the body of the managed env block (no markers) from a registered
-* schema map.
-*
-* Grouped by:
-*   1. required (no default, not optional)
-*   2. required with default (prefilled value)
-*   3. optional (empty value)
-*
-* Enum-valued keys get a leading `# enum: A | B | C` comment.
-*/
-function formatEnvExample(schema) {
-	const entries = Object.entries(schema).map(([key, s]) => ({
-		key,
-		classification: classifySchema(s)
-	}));
-	const required = entries.filter((e) => e.classification.kind === "required");
-	const withDefault = entries.filter((e) => e.classification.kind === "default");
-	const optional = entries.filter((e) => e.classification.kind === "optional");
-	const lines = [];
-	const writeGroup = (label, group) => {
-		if (group.length === 0) return;
-		if (lines.length > 0) lines.push("");
-		lines.push(`# ${label}`);
-		for (const entry of group) {
-			const enumValues = entry.classification.enumValues;
-			if (enumValues && enumValues.length > 0) lines.push(`# enum: ${enumValues.join(" | ")}`);
-			if (entry.classification.kind === "default") lines.push(`${entry.key}=${serializeDefault(entry.classification.defaultValue)}`);
-			else lines.push(`${entry.key}=`);
-		}
-	};
-	writeGroup("required", required);
-	writeGroup("with defaults", withDefault);
-	writeGroup("optional", optional);
-	return lines.join("\n") + (lines.length > 0 ? "\n" : "");
-}
-/**
-* Literal start/end markers for the void-managed block. They are valid
-* dotenv comments (hash-prefixed) so any tool that parses `.env.example`
-* silently ignores them, and they are matched as whole lines (with
-* defensive trailing-whitespace tolerance) when locating the block.
-*/
-const ENV_EXAMPLE_START_MARKER = "# >>> void env: managed block — do not edit between markers <<<";
-const ENV_EXAMPLE_END_MARKER = "# >>> end void env <<<";
-const ENV_EXAMPLE_MARKER_HINT = "# Run `void env example` to refresh.";
-/** Regex matchers for the markers — full line, ignore trailing whitespace. */
-const START_MARKER_RE = new RegExp(`^${ENV_EXAMPLE_START_MARKER.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*$`);
-const END_MARKER_RE = new RegExp(`^${ENV_EXAMPLE_END_MARKER.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*$`);
-function buildMarkerBlock(body) {
-	const trimmedBody = body.endsWith("\n") ? body.slice(0, -1) : body;
-	const parts = [ENV_EXAMPLE_START_MARKER, ENV_EXAMPLE_MARKER_HINT];
-	if (trimmedBody.length > 0) parts.push(trimmedBody);
-	parts.push(ENV_EXAMPLE_END_MARKER);
-	return parts.join("\n") + "\n";
-}
-/**
-* Pure helper that produces the new `.env.example` content given the
-* existing file contents (or `null` when the file does not exist) and the
-* formatted env body (without marker lines).
-*
-* Behavior matrix:
-*   - existing == null               → `create` a fresh marker-only file
-*   - both markers present           → `replace` the lines between them
-*   - no markers present             → `append` the block at the end
-*   - exactly one marker present     → `error` (mismatched markers)
-*/
-function applyMarkerBlock(existing, body) {
-	const block = buildMarkerBlock(body);
-	if (existing === null) return {
-		content: block,
-		action: "create"
-	};
-	const lines = existing.split("\n");
-	let startIdx = -1;
-	let endIdx = -1;
-	for (let i = 0; i < lines.length; i++) {
-		if (startIdx === -1 && START_MARKER_RE.test(lines[i])) {
-			startIdx = i;
-			continue;
-		}
-		if (startIdx !== -1 && END_MARKER_RE.test(lines[i])) {
-			endIdx = i;
-			break;
-		}
-	}
-	const hasStart = lines.some((l) => START_MARKER_RE.test(l));
-	const hasEnd = lines.some((l) => END_MARKER_RE.test(l));
-	if (hasStart && !hasEnd) return {
-		content: existing,
-		action: "error",
-		reason: "Found start marker but no matching end marker in .env.example. Restore `# >>> end void env <<<` or delete the file and re-run `void env example`."
-	};
-	if (!hasStart && hasEnd) return {
-		content: existing,
-		action: "error",
-		reason: "Found end marker but no matching start marker in .env.example. Restore `# >>> void env: ... <<<` or delete the file and re-run `void env example`."
-	};
-	if (startIdx !== -1 && endIdx !== -1) {
-		const before = lines.slice(0, startIdx);
-		const after = lines.slice(endIdx + 1);
-		const beforeText = before.length > 0 ? before.join("\n") + "\n" : "";
-		const afterText = after.join("\n");
-		return {
-			content: beforeText + block + afterText,
-			action: "replace"
-		};
-	}
-	const trimmed = existing.replace(/\s+$/, "");
-	return {
-		content: trimmed + (trimmed.length > 0 ? "\n\n" : "") + block,
-		action: "append"
-	};
-}
-/** CLI entrypoint: load schema, manage marker block, write `.env.example`. */
-async function runEnvExample(root, options) {
-	const envFile = findEnvFile(root);
-	if (!envFile) {
-		outro("No env.ts found at project root — nothing to generate.");
-		return;
-	}
-	const schema = await loadRegisteredSchema(envFile);
-	if (!schema || Object.keys(schema).length === 0) {
-		outro("env.ts registered no keys — nothing to generate.");
-		return;
-	}
-	const outPath = join(root, ".env.example");
-	const existing = existsSync(outPath) ? readFileSync(outPath, "utf-8") : null;
-	const result = applyMarkerBlock(existing, formatEnvExample(schema));
-	if (result.action === "error") {
-		log.error(result.reason ?? "Failed to update .env.example.");
-		process.exit(1);
-	}
-	if (existing !== null && existing === result.content) {
-		outro(".env.example is already up to date.");
-		return;
-	}
-	writeFileSync(outPath, result.content);
-	const count = Object.keys(schema).length;
-	const keyCount = `${count} key${count === 1 ? "" : "s"}`;
-	if (result.action === "create") log.success(`Wrote .env.example (${keyCount}).`);
-	else if (result.action === "replace") log.success(`Refreshed void env block in .env.example (${keyCount}).`);
-	else if (result.action === "append") {
-		log.success(`Refreshed void env block in .env.example (${keyCount}).`);
-		if (!options.force) log.info("appended void env block to existing .env.example");
-	}
-	outro("Done.");
-}
-//#endregion
-//#region src/cli/env.ts
-async function runEnvCommand(root, args) {
-	console.log();
-	intro(cliTitle(`env ${args.subcommand}`));
-	if (args.subcommand === "check") {
-		await runCheck(root, args.useRemoteSecrets);
-		return;
-	}
-	if (args.subcommand === "types") {
-		runTypes(root);
-		return;
-	}
-	if (args.subcommand === "example") {
-		await runEnvExample(root, { force: args.force });
-		return;
-	}
-}
-async function runCheck(root, useRemoteSecrets) {
-	let remoteSecrets;
-	if (useRemoteSecrets) {
-		const token = getToken(root);
-		if (!token) {
-			log.error("--remote requires authentication. Run `void auth login` first.");
-			process.exit(1);
-		}
-		const config = readProjectConfig(root);
-		if (!config) {
-			log.error("--remote requires a linked project. Run `void project link` first.");
-			process.exit(1);
-		}
-		remoteSecrets = await fetchRemoteSecretNames(new PlatformClient(token, { root }), config.projectId);
-	}
-	const { hasSchema, report } = await validateProdEnv(root, {
-		productionOnly: true,
-		remoteSecrets
-	});
-	if (!hasSchema) {
-		outro("No env.ts found — nothing to validate.");
-		return;
-	}
-	if (report.valid) {
-		outro("All required env vars are present and valid.");
-		return;
-	}
-	note(formatEnvReport(report), "Env validation failed");
-	if (report.missing.length > 0) log.info(`Set missing values via .env / .env.production, or upload as secrets with \`void secret put <NAME>\`.`);
-	process.exit(1);
-}
-function runTypes(root) {
-	const envFile = findEnvFile(root);
-	if (!envFile) {
-		outro("No env.ts found at project root — nothing to generate.");
-		return;
-	}
-	const outDir = join(root, ".void");
-	mkdirSync(outDir, { recursive: true });
-	const { dts } = generateEnvTypes(envFile, outDir);
-	writeFileSync(join(outDir, "env.d.ts"), dts);
-	outro(`Wrote ${join(".void", "env.d.ts")}.`);
-}
-//#endregion
-export { runEnvCommand };