void 0.7.13 → 0.8.0

package/dist/{yarn-pnp-6LD6_3Ej.mjs → yarn-pnp-QgEYVC3V.mjs}

@@ -1,4 +1,4 @@
-import { a as join, n as dirname } from "./pathe.M-eThtNZ-D-kmWkCS.mjs";
+import { a as join, n as dirname } from "./pathe.M-eThtNZ-BrPhGF_K.mjs";
 import { existsSync, readdirSync } from "node:fs";
 import { pathToFileURL } from "node:url";
 //#region src/cli/yarn-pnp.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "void",
-  "version": "0.7.13",
+  "version": "0.8.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/voidzero-dev/void.git",
@@ -48,6 +48,7 @@
       "import": "./dist/index.mjs",
       "require": "./dist/index.mjs"
     },
+    "./schema.json": "./schema.json",
     "./handler": {
       "types": "./dist/runtime/handler.d.mts",
       "import": "./dist/runtime/handler.mjs",
@@ -332,7 +333,7 @@
     "valibot": ">=1.0.0-beta.7",
     "vite": "^8.0.0",
     "zod": "^3.25.0 || ^4.0.0",
-    "@void/md": "0.7.13"
+    "@void/md": "0.8.0"
   },
   "peerDependenciesMeta": {
     "@void/md": {

package/schema.json

@@ -8,6 +8,11 @@
       "type": "string",
       "description": "JSON Schema URL for IDE support"
     },
+    "sourceDir": {
+      "type": "string",
+      "pattern": "^(?!/)(?!\\.\\.?$)(?!\\./$)(?!\\.\\./)(?!.*(?:^|/)\\.\\.(?:/|$))(?!.*\\s$)(?!\\s).+$",
+      "description": "Directory containing Void source conventions such as pages, routes, middleware, crons, queues, db, auth.ts, and env.ts. Omit to use the project root."
+    },
     "target": {
       "type": "string",
       "enum": ["cloudflare", "node", "bun", "deno"],

package/skills/void/docs/guide/ai.md

@@ -208,7 +208,7 @@ All [AI Gateway providers](https://developers.cloudflare.com/ai-gateway/usage/pr
 For production, add your API key as a project secret:
 
 ```bash
-void secrets set OPENAI_API_KEY sk-...
+void secret put OPENAI_API_KEY=sk-...
 ```
 
 For local development, add it to `.env.local` in your project root:

package/skills/void/docs/guide/app-types.md

@@ -50,7 +50,7 @@ Void supports deploying Vite-based meta-framework apps with `void deploy`. The f
 | [Analog](https://analogjs.org/)                     | `@analogjs/platform`    | [Guide](../integrations/frameworks/analog.md)         |
 | [Astro](https://astro.build/)                       | `astro`                 | [Guide](../integrations/frameworks/astro.md)          |
 
-Add `voidPlugin()` to the framework's Vite config to get binding inference, typed DB generation, migration management, auth, cron jobs, queues, and caching. See the [Meta Frameworks Integration](../integrations/frameworks/overview.md) for the full feature matrix, deploy pipeline, and per-framework setup guides.
+Add `voidPlugin()` to the framework's Vite config to get binding inference, typed DB generation, migration management, cron jobs, queues, and caching. Void-managed auth is not supported in framework mode; use Better Auth's official integration for your framework. See the [Meta Frameworks Integration](../integrations/frameworks/overview.md) for the full feature matrix, deploy pipeline, and per-framework setup guides.
 
 **Deploy:** `void deploy` runs the framework build, packages the output, and deploys to Void. The framework still owns routing and SSR, while Void handles resource provisioning, migrations, and edge hosting.
 

package/skills/void/docs/guide/database/postgresql.md

@@ -32,7 +32,7 @@ For local development, add `DATABASE_URL` to `.env.local`:
 DATABASE_URL=postgres://user:password@host:5432/mydb
 ```
 
-This connects directly to your Postgres database during `void dev`.
+This connects directly to your Postgres database during local Vite development.
 
 ### 3. Deploy
 

package/skills/void/docs/guide/edge/headers.md

@@ -74,6 +74,6 @@ No configuration is needed. If the framework generates a `_headers` file, it is
 
 1. `void deploy` reads header rules from the framework `_headers` file (if present) and `routing.headers` in `void.json`, then includes them in the deploy manifest.
 2. The platform stores the rules in the KV routing entry for your project.
-3. The dispatch worker applies matching rules to static responses before edge caching.
+3. The dispatch worker applies matching rules to matching responses before returning them. Cacheable responses are cached with the final headers.
 
 Because rules are evaluated at the edge, there is no extra latency cost. Headers are applied inline before the response is returned and cached.

package/skills/void/docs/guide/edge/static-assets.md

@@ -67,6 +67,40 @@ This happens automatically for all static assets. No configuration is needed.
 
 You can override caching headers or add your own for any static asset path using [Custom Headers](./headers).
 
+## Request pipeline
+
+Static assets can run in front of the worker, behind the worker, or without any worker at all. Void chooses the pipeline from the app shape so static pages stay static unless application code must inspect document navigations.
+
+### Deploy shapes
+
+| Shape                                                                                   | Worker deployed | First handler for assets | First handler for document navigations | Miss behavior                                                                                                          |
+| --------------------------------------------------------------------------------------- | --------------- | ------------------------ | -------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
+| `inference.appType: "static"`                                                           | No              | Asset platform           | Asset platform                         | Platform 404 page.                                                                                                     |
+| Static SPA deploy                                                                       | No              | Asset platform           | Asset platform                         | Platform serves `/index.html` for unmatched navigations. If user `routing.fallbacks` exist, Void ships fallback rules. |
+| Void app with only `/api` routes                                                        | Yes             | Asset platform           | Asset platform                         | Static navigations keep the platform SPA fallback; API asset misses fall through to the worker route table.            |
+| Void app with `middleware/`, managed auth, non-`/api` routes, WebSockets, live bindings | Yes             | Worker first             | Worker first                           | Asset misses stay 404, then the worker serves `/index.html` for HTML requests after routes and middleware run.         |
+| Pages, SSR, and framework apps                                                          | Yes             | Worker first             | Worker first                           | Asset misses stay 404. Pages, SSR, or framework rendering owns HTML responses, including intentional HTML 404s.        |
+
+### Worker-first Void apps
+
+For worker-owned HTML, Void sets Cloudflare assets to `not_found_handling: "none"` and configures `run_worker_first`. The request order is:
+
+1. Platform routing rules that always run before assets, such as redirects and forced rewrites.
+2. Worker route table, middleware, auth, WebSocket upgrades, Pages, or SSR.
+3. `env.ASSETS.fetch()` from inside the worker for static files.
+4. For non-Pages, non-SSR Void apps only, a worker-side SPA fallback to `/index.html` when the original request accepts HTML.
+5. The worker's original 404.
+
+This is the path needed for preview auth and other middleware. Cloudflare's platform SPA fallback can serve `index.html` directly for browser navigations; when that happens, middleware never sees the request. Worker-owned HTML avoids that by moving fallback HTML behind middleware.
+
+### Asset-first Void apps
+
+For Void apps with only `/api` routes, Void does not enable `run_worker_first`. Static assets and SPA navigations stay on the asset platform. Requests that do not resolve to an asset and are not handled by the platform SPA fallback, such as `/api/hello`, fall through to the worker.
+
+### Generated config
+
+Void owns the generated asset routing policy during dev and build. If a root `wrangler.jsonc` contains stale `not_found_handling` or `run_worker_first` values, Void replaces those fields so generated config cannot accidentally change which layer sees a request first.
+
 ## API routes and SSR pages
 
 API responses (`/api/*`) and SSR-rendered pages without file extensions always hit the worker. They are **not** edge-cached by the dispatch layer.

package/skills/void/docs/guide/sandboxes.md

@@ -12,7 +12,7 @@ import { getSandbox } from 'void/sandbox';
 
 export const POST = defineHandler(async (c) => {
   const { command } = await c.req.json<{ command: string }>();
-  const sandbox = getSandbox('default');
+  const sandbox = await getSandbox('default');
   const result = await sandbox.exec(command);
 
   return c.json(result);
@@ -58,7 +58,8 @@ Available fields:
 ```ts
 import { getSandbox } from 'void/sandbox';
 
-const sandbox = getSandbox(`user-${user.id}`);
+// inside an async handler
+const sandbox = await getSandbox(`user-${user.id}`);
 await sandbox.writeFile('/tmp/input.txt', 'hello');
 const result = await sandbox.exec('cat /tmp/input.txt');
 ```

package/skills/void/docs/guide/ssr.md

@@ -10,6 +10,28 @@ Void supports framework-agnostic SSR via explicit server and client entries. Thi
 For most apps, [Pages Routing](./pages-routing/overview) handles SSR automatically. You do not need entry files or hydration code.
 :::
 
+## Relationship to Pages Routing
+
+Custom SSR is separate from Pages Routing. Use Custom SSR when you want to bring
+your own root component, router, data loading, HTML shell, and hydration logic.
+
+The `App` component in the examples below is not a Void convention and it is not
+the same thing as `pages/layout.tsx`. It is just the root component for your
+custom-rendered application:
+
+```tsx
+// src/App.tsx
+export default function App({ url }: { url: string }) {
+  return url === '/about' ? <main>About</main> : <main>Home</main>;
+}
+```
+
+If you are using `pages/` with `@void/react`, `@void/vue`, `@void/svelte`, or
+`@void/solid`, do not create `src/main.ssr.*`, `src/main.client.*`, or
+`src/App.*` for Pages mode. The adapter generates the SSR and hydration entries
+and automatically composes your `pages/layout.*`, route components, loaders, and
+actions.
+
 ## Required entries
 
 SSR mode is enabled when both of these exist:
@@ -40,8 +62,9 @@ The recommended form is `defineRender(...)` for inferred types.
 
 ```ts
 {
-  head: string; // styles/modulepreload/Vite client+preamble (dev)
-  body: string; // main client entry script tag
+  css: string; // stylesheet links for <head>
+  preloads: string; // modulepreload/Vite client+preamble tags for <head>
+  body: string; // main client entry script tag before </body>
 }
 ```
 

package/skills/void/docs/integrations/cloudflare.md

@@ -38,7 +38,7 @@ export const GET = defineHandler(async (c) => {
 
 ### Via `cloudflare:workers` import
 
-When using framework mode (TanStack Start, React Router, SolidStart), the framework owns routing and you access bindings through the `cloudflare:workers` module instead:
+When using framework mode (TanStack Start or React Router), the framework owns routing and you access bindings through the `cloudflare:workers` module instead:
 
 ::: warning ⚠️ Cloudflare env access in meta frameworks
 Some frameworks, like Nuxt and SvelteKit, do not run in workerd during dev and therefore do not support directly importing from `cloudflare:workers`.
@@ -91,7 +91,7 @@ This augments the `Cloudflare.Env` interface with `DB`, `KV`, `STORAGE`, `AI`, a
 | `KV`      | `KVNamespace` | `env.KV` / `c.env.KV` or `import from "void/kv"`                |
 | `STORAGE` | `R2Bucket`    | `env.STORAGE` / `c.env.STORAGE` or `import from "void/storage"` |
 | `AI`      | `Ai`          | `env.AI` / `c.env.AI` or `import from "void/ai"`                |
-| `QUEUE_*` | `Queue<T>`    | `defineQueue()` or `import from "void/queue"`                   |
+| `QUEUE_*` | `Queue<T>`    | `defineQueue()` or `import { queues } from "void/queues"`       |
 
 Bindings are [inferred automatically](../reference/resource-inference.md) by scanning your source files for import and access patterns. You can also set them explicitly in `void.json`:
 
@@ -120,7 +120,7 @@ You can set non-binding wrangler fields like `compatibility_date` and `compatibi
 }
 ```
 
-For environment variables, use `.env` files instead of `worker.vars`. Void automatically loads `.env` files through Vite's `loadEnv` and merges them into the worker's `vars` bindings:
+For environment variables, use `.env` files for local values and secrets. Void automatically loads `.env` files through Vite's `loadEnv` and merges them into the worker's `vars` bindings:
 
 ```bash
 # .env
@@ -129,6 +129,8 @@ API_URL=https://api.example.com
 
 Binding arrays such as `d1_databases`, `kv_namespaces`, and `r2_buckets` are not allowed in the `worker` field because Void manages bindings for you. If you need custom bindings with real resource IDs, add a `wrangler.jsonc` to the project root instead. See [Wrangler config merging](#wrangler-config-merging) for details.
 
+For non-secret plain-text defaults, you can also set `worker.vars` in `void.json`. Values from `.env` files override `worker.vars`.
+
 ## Wrangler config merging
 
 By default, Void configures the Cloudflare plugin programmatically, so you don't need a `wrangler.jsonc` for bindings. Void pins a Workers compatibility date in `void.json` `worker.compatibility_date`; if no date is already configured in `void.json` or `wrangler.jsonc`/`wrangler.json`, Void writes the latest known-good date to `void.json`. Bindings are inferred from your source code and provisioned with local placeholder IDs for development.

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

@@ -57,7 +57,7 @@ Most configuration is inferred automatically. Use `void.json` to override defaul
 
 ```json
 {
-  "$schema": "https://unpkg.com/void/schema.json",
+  "$schema": "./node_modules/void/schema.json",
   "inference": {
     "build": "nuxt build",
     "scanDirs": ["src", "server", "lib"],

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

@@ -106,18 +106,19 @@ These Void features work identically across all targets:
 
 The following imports are **not available** with a non-CF target and produce a compile-time error:
 
-| Import         | CF Feature                   |
-| -------------- | ---------------------------- |
-| `void/db`      | D1 (SQL database)            |
-| `void/kv`      | KV (key-value storage)       |
-| `void/storage` | R2 (blob storage)            |
-| `void/auth`    | Void-managed Better Auth     |
-| `void/ai`      | Workers AI                   |
-| `void/env`     | CF env type augmentation     |
-| `void/ws`      | Durable Objects + WebSockets |
+| Import         | CF Feature               |
+| -------------- | ------------------------ |
+| `void/db`      | D1 (SQL database)        |
+| `void/kv`      | KV (key-value storage)   |
+| `void/storage` | R2 (blob storage)        |
+| `void/auth`    | Void-managed Better Auth |
+| `void/ai`      | Workers AI               |
+| `void/env`     | CF env type augmentation |
 
 If you need a database or storage, use an external provider and connect via standard Node.js libraries.
 
+Void-managed WebSocket route files (`*.ws.ts`) are still Cloudflare-only because they compile to Durable Objects. The `void/ws` subpath is not compile-time blocked on non-CF targets, so browser-side `connect()` code can still be bundled when a WebSocket runtime is available.
+
 ### No cron job runtime
 
 You can still define [cron jobs](../guide/jobs.md) in `crons/` and they will compile into the bundle, but there is no built-in scheduler to invoke them. On Cloudflare, Workers Cron Triggers call the `scheduled` handler automatically. On Node.js, you'll need an external scheduler (e.g. `node-cron`, systemd timers, or your hosting platform's cron) to trigger the exported handler.

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

@@ -4,7 +4,7 @@ outline: deep
 
 # API Reference
 
-This page is the source of truth for public `void` exports. Use it when you already know what feature you want and need the exact import, signature, or return type.
+This page is the source of truth for user-facing `void` exports. Use it when you already know what feature you want and need the exact import, signature, or return type. Some exported subpaths are implementation support for adapters, generated workers, or internal runtime wiring and are intentionally not listed as app APIs.
 
 ## Plugin
 
@@ -193,7 +193,8 @@ function defineRender(
 
 ```ts
 interface RenderAssetTags {
-  head: string; // Script and style tags for <head>
+  css: string; // Stylesheet links for <head>
+  preloads: string; // Modulepreload and dev client tags for <head>
   body: string; // Script tags for before </body>
 }
 ```
@@ -533,11 +534,11 @@ The typed client is built on [ofetch](https://github.com/unjs/ofetch) with a typ
 
 ## Database
 
-Imported from `"void/db"`. The `db` export is a [Drizzle ORM](https://orm.drizzle.team) instance for [Cloudflare D1](https://developers.cloudflare.com/d1/). See the [Database guide](../guide/database.md) for usage and the [Drizzle docs](https://orm.drizzle.team/docs/select) for the full query API.
+Imported from `"void/db"`. The `db` export is a [Drizzle ORM](https://orm.drizzle.team) instance for the configured database dialect: [Cloudflare D1](https://developers.cloudflare.com/d1/) by default, or PostgreSQL when `void.json` sets `"database": "pg"` / `"postgresql"`. See the [Database guide](../guide/database.md) for usage and the [Drizzle docs](https://orm.drizzle.team/docs/select) for the full query API.
 
 ### `db`
 
-Default Drizzle D1 instance, pre-wired with the `env.DB` binding and your schema from `db/schema.ts`.
+Default Drizzle instance, pre-wired with your schema from `db/schema.ts`.
 
 ```ts
 import { db } from 'void/db';
@@ -546,11 +547,18 @@ import { users } from '@schema';
 const allUsers = await db.select().from(users).all();
 ```
 
-When the Void plugin is active, `void/db` is served as a virtual module that auto-wires the D1 binding with your schema. The published npm fallback uses a lazy proxy that resolves the `DB` binding at first access.
+When the Void plugin is active, `void/db` is served as a virtual module that auto-wires the active database with your schema.
+
+- D1 projects resolve the `DB` binding and expose `DrizzleD1Database<Schema>`.
+- PostgreSQL projects use `DATABASE_URL` during local development and Hyperdrive's `connectionString` in production, exposing `NodePgDatabase<Schema>`.
+
+The published npm fallback uses a lazy D1 proxy that resolves the `DB` binding at first access.
 
 ### `createDb(database)`
 
-Creates a Drizzle D1 instance from a specific D1 binding. Use this when you have multiple D1 databases or need a non-default binding.
+Creates a Drizzle instance for the active dialect.
+
+For D1 projects, pass a specific D1 binding. Use this when you have multiple D1 databases or need a non-default binding.
 
 ```ts
 import { createDb } from 'void/db';
@@ -559,10 +567,22 @@ import { env } from 'cloudflare:workers';
 const db = createDb(env.MY_OTHER_DB);
 ```
 
+For PostgreSQL projects, pass a connection string.
+
+```ts
+import { createDb } from 'void/db';
+
+const db = createDb('postgres://user:password@host:5432/app');
+```
+
 **Signature:**
 
 ```ts
-function createDb(d1: D1Database): DrizzleD1Database;
+// D1
+function createDb(d1: D1Database): DrizzleD1Database<Schema>;
+
+// PostgreSQL
+function createDb(connectionString: string): NodePgDatabase<Schema>;
 ```
 
 ### Query Operators
@@ -602,6 +622,98 @@ The callback receives:
 
 Seed modules can export either `default` or a named `seed` function.
 
+## KV
+
+Imported from `"void/kv"`.
+
+### `kv`
+
+Typed JSON-aware client for the inferred `KV` binding.
+
+```ts
+import { kv } from 'void/kv';
+
+await kv.put('settings', { theme: 'dark' });
+const settings = await kv.get<{ theme: string }>('settings');
+```
+
+**Key exports:** `kv`, `createKV(namespace)`, `KVClient`, `KVMap`, `PutOptions`, `ListOptions`.
+
+`kv.map(prefix)` creates a typed namespaced view where every key is stored under `prefix:`.
+
+## Storage
+
+Imported from `"void/storage"`.
+
+### `storage`
+
+Default [R2 bucket](https://developers.cloudflare.com/r2/) proxy for the inferred `STORAGE` binding.
+
+```ts
+import { storage } from 'void/storage';
+
+await storage.put('avatars/alice.png', file);
+const object = await storage.get('avatars/alice.png');
+```
+
+**Key exports:** `storage`, `createStorage(bucket)`.
+
+## AI
+
+Imported from `"void/ai"`.
+
+### `ai`
+
+Typed AI client for Workers AI models and AI Gateway-backed third-party providers.
+
+```ts
+import { ai } from 'void/ai';
+
+const result = await ai.run('@cf/meta/llama-3.1-8b-instruct', {
+  messages: [{ role: 'user', content: 'Summarize this release note.' }],
+});
+```
+
+**Key exports:** `ai`, `VoidAi`, model input/response types. See [AI](../guide/ai.md) for provider setup and streaming examples.
+
+## ISR
+
+Imported from `"void/isr"`.
+
+### `revalidate(options)`
+
+Revalidate ISR-cached pages on demand. In local development this is a no-op because there is no edge ISR cache.
+
+```ts
+import { revalidate } from 'void/isr';
+
+await revalidate({ paths: ['/', '/blog/hello'] });
+await revalidate({ all: true });
+```
+
+**Signature:**
+
+```ts
+function revalidate(options: { paths?: string[]; all?: boolean }): Promise<void>;
+```
+
+## Logging
+
+Imported from `"void/log"`.
+
+### `logger`
+
+Structured logger that emits one JSON line per call so deployed logs can be filtered by message and fields.
+
+```ts
+import { logger } from 'void/log';
+
+logger.info('checkout completed', { orderId, userId });
+logger.error('webhook failed', { provider: 'stripe', attempt: 3 });
+```
+
+**Methods:** `logger.error(message, fields?)`, `logger.warn(message, fields?)`, `logger.info(message, fields?)`.
+
 ## Types
 
 ### `CloudContext`
@@ -691,9 +803,42 @@ Empty stub interface augmented at build time by the generated `.void/routes.d.ts
 import type { RouteMap } from 'void/routes';
 ```
 
-## Environment Types
+## Environment
+
+Imported from `"void/env"`.
+
+### `defineEnv(schema)`
 
-Importing `"void/env"` provides global Cloudflare environment types:
+Register an env schema and return the typed [`env`](#env) proxy. Void auto-discovers `env.ts`, imports it during dev/build/deploy, generates `.void/env.d.ts`, validates production secrets before deploy, and validates values at worker boot.
+
+```ts
+import { defineEnv, string, number, oneOf, url } from 'void/env';
+
+export default defineEnv({
+  STRIPE_KEY: string().secret(),
+  PORT: number().default(3000),
+  NODE_ENV: oneOf(['development', 'production']),
+  VITE_PUBLIC_URL: url().public(),
+});
+```
+
+### `env`
+
+Typed runtime proxy for declared env keys. Unknown keys and bindings pass through as `unknown`.
+
+```ts
+import { env } from 'void/env';
+
+const port = env.PORT;
+```
+
+### Schema helpers
+
+`void/env` includes Standard Schema-compatible helpers: `string()`, `number()`, `boolean()`, `url()`, `email()`, `oneOf([...])`, and `json<T>()`. Each helper supports `.optional()`, `.default(value)`, `.secret()`, and `.public()`.
+
+### Types
+
+`void/env` also provides global Cloudflare environment types:
 
 ```ts
 /// <reference types="void/env" />
@@ -732,6 +877,7 @@ function voidVue(options?: VoidVueOptions): Plugin[];
 ```ts
 interface VoidVueOptions {
   vue?: VuePluginOptions; // passed through to @vitejs/plugin-vue
+  viewTransitions?: boolean; // enable View Transitions API for navigations
 }
 ```
 
@@ -746,6 +892,8 @@ Imported from `"@void/vue"`.
 | `useParams()`                      | Returns dynamic route params for the page currently being rendered.                                                                                                                                                                               |
 | `useNavigation()`                  | Returns pending navigation state: `{ state, location, method }`, where `state` is `"idle"`, `"loading"`, or `"submitting"` and `location` is the pending destination.                                                                             |
 | `useForm(url, defaults, options?)` | Typed reactive form helper bound to a page action URL. Returns `{ data, post, put, patch, delete, pending, errors, error, hasChanges, wasSuccessful, recentlySuccessful, reset, clearErrors, clearError }`.                                       |
+| `useIslandForm(defaults)`          | Form helper for island components where the action URL is inferred from the current island request. Returns the same form state and submit helpers as `useForm()`.                                                                                |
+| `action(url, options?)`            | Awaitable one-shot page action helper. Uses `POST` by default and accepts `{ data, method, params }`, where `method` can be `"PUT"`, `"PATCH"`, or `"DELETE"`. Returns an `ActionResult`.                                                         |
 | `useShared()`                      | Returns shared data injected by middleware via `c.set("shared", {...})`.                                                                                                                                                                          |
 
 Vue `Link` GET `data` is merged into the rendered `href` query string. Primitive values are serialized with `String(value)`, arrays become repeated keys, `null` and `undefined` are omitted, and nested objects throw. `prefetch` and `reloadDocument` are GET-only and throw for mutation links.
@@ -794,6 +942,7 @@ Imported from `"@void/react"`.
 | `useParams()`                      | Returns dynamic route params for the page currently being rendered.                                                                                                                                                                                 |
 | `useNavigation()`                  | Returns pending navigation state: `{ state, location, method }`, where `state` is `"idle"`, `"loading"`, or `"submitting"` and `location` is the pending destination.                                                                               |
 | `useForm(url, defaults, options?)` | Form helper hook. Returns `{ data, setData, post, put, patch, delete, pending, errors, error, hasChanges, wasSuccessful, recentlySuccessful, reset, clearErrors, clearError }`.                                                                     |
+| `useIslandForm(defaults)`          | Form helper hook for island components where the action URL is inferred from the current island request. Returns the same form state and submit helpers as `useForm()`.                                                                             |
 | `action(url, options?)`            | Awaitable one-shot page action helper. Uses `POST` by default and accepts `{ data, method, params }`, where `method` can be `"PUT"`, `"PATCH"`, or `"DELETE"`. Returns an `ActionResult`.                                                           |
 | `useShared()`                      | Returns shared data injected by middleware via `c.set("shared", {...})`.                                                                                                                                                                            |
 | `Deferred<T>`                      | React-only prop type for `defer()` results. It is `Promise<T>` and is consumed with React `use()`.                                                                                                                                                  |
@@ -835,6 +984,10 @@ function voidSvelte(options?: VoidSvelteOptions): Plugin[];
 interface VoidSvelteOptions {
   svelte?: SveltePluginOptions; // passed through to @sveltejs/vite-plugin-svelte
   viewTransitions?: boolean; // enable View Transitions API
+  prefetch?: {
+    hoverDelay?: number;
+    cacheFor?: number | string | [string, string];
+  };
 }
 ```
 
@@ -846,6 +999,8 @@ Imported from `"@void/svelte"`.
 | ---------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `Link`                             | Svelte component for SPA navigation. Renders `<a>` for GET, `<button>` for non-GET methods. Props: `href`, `method`, `data`, `prefetch`, `cacheFor`, `preserveScroll`, `preserveState`, `replace`, `reloadDocument`, `viewTransition`, `onNavigate`. |
 | `useForm(url, defaults, options?)` | Form helper using Svelte 5 runes. Returns `{ data, post, put, patch, delete, pending, errors, error, hasChanges, wasSuccessful, recentlySuccessful, reset, clearErrors, clearError }`.                                                               |
+| `useIslandForm(defaults)`          | Form helper for island components where the action URL is inferred from the current island request. Returns the same form state and submit helpers as `useForm()`.                                                                                   |
+| `action(url, options?)`            | Awaitable one-shot page action helper. Uses `POST` by default and accepts `{ data, method, params }`, where `method` can be `"PUT"`, `"PATCH"`, or `"DELETE"`. Returns an `ActionResult`.                                                            |
 | `useShared()`                      | Returns shared data injected by middleware via `c.set("shared", {...})`.                                                                                                                                                                             |
 | `useRouter()`                      | Returns the Void Router with current route state (`url`, `path`, `query`, `params`) and navigation methods: `visit`, `refresh`, awaitable `prefetch`, `flush`, `flushAll`.                                                                           |
 | `useParams()`                      | Returns dynamic route params for the page currently being rendered.                                                                                                                                                                                  |
@@ -879,6 +1034,10 @@ function voidSolid(options?: VoidSolidOptions): Plugin[];
 interface VoidSolidOptions {
   solid?: SolidPluginOptions; // passed through to vite-plugin-solid
   viewTransitions?: boolean; // enable View Transitions API
+  prefetch?: {
+    hoverDelay?: number;
+    cacheFor?: number | string | [string, string];
+  };
 }
 ```
 
@@ -890,6 +1049,8 @@ Imported from `"@void/solid"`.
 | ---------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `Link`                             | Solid component for SPA navigation. Renders `<a>` for GET, `<button>` for non-GET methods. Props: `href`, `method`, `data`, `prefetch`, `cacheFor`, `preserveScroll`, `preserveState`, `replace`, `reloadDocument`, `viewTransition`, `onNavigate`. |
 | `useForm(url, defaults, options?)` | Form helper using Solid stores. Returns `{ data, setData, post, put, patch, delete, pending, errors, error, hasChanges, wasSuccessful, recentlySuccessful, reset, clearErrors, clearError }`.                                                       |
+| `useIslandForm(defaults)`          | Form helper for island components where the action URL is inferred from the current island request. Returns the same form state and submit helpers as `useForm()`.                                                                                  |
+| `action(url, options?)`            | Awaitable one-shot page action helper. Uses `POST` by default and accepts `{ data, method, params }`, where `method` can be `"PUT"`, `"PATCH"`, or `"DELETE"`. Returns an `ActionResult`.                                                           |
 | `useShared()`                      | Returns shared data injected by middleware via `c.set("shared", {...})`.                                                                                                                                                                            |
 | `useRouter()`                      | Returns the Void Router with current route state (`url`, `path`, `query`, `params`) and navigation methods: `visit`, `refresh`, awaitable `prefetch`, `flush`, `flushAll`.                                                                          |
 | `useParams()`                      | Returns dynamic route params for the page currently being rendered.                                                                                                                                                                                 |
@@ -897,11 +1058,35 @@ Imported from `"@void/solid"`.
 
 Solid `Link` GET `data` is merged into the rendered `href` query string. Primitive values are serialized with `String(value)`, arrays become repeated keys, `null` and `undefined` are omitted, and nested objects throw. `prefetch` and `reloadDocument` are GET-only and throw for mutation links.
 
-## Subpath Exports
+## Markdown Package
+
+The optional `@void/md` package adds Markdown pages to Pages Routing. Install it alongside a Pages adapter and add `voidMarkdown()` to your Vite plugins.
+
+```ts
+import { voidMarkdown } from '@void/md/plugin';
+
+export default defineConfig({
+  plugins: [voidPlugin(), voidReact(), voidMarkdown()],
+});
+```
+
+| Import path                  | Contents                                                                                 |
+| ---------------------------- | ---------------------------------------------------------------------------------------- |
+| `@void/md/plugin`            | `voidMarkdown(options?)`, `MarkdownOptions`, `MdPage`                                    |
+| `@void/md`                   | `useFrontmatter()`, `FrontmatterContext`, `setFrontmatter()`, `MdPage`                   |
+| `@void/md/pages`             | Generated metadata for Markdown pages, used for navigation, sidebars, and search indexes |
+| `@void/md/theme.css`         | Full Markdown theme styles                                                               |
+| `@void/md/theme-content.css` | Content-only Markdown styles for apps that provide their own shell/layout                |
+
+See [Markdown Pages](../guide/pages-routing/markdown.md) for setup and framework-specific examples.
+
+## User-Facing Imports
+
+This table lists app-facing imports. Exported implementation subpaths such as `void/pages*`, `void/runtime/*`, and `void/remote*` are used by adapters, generated entries, or internal runtime wiring and are not documented as application APIs.
 
 | Import path            | Contents                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
 | ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `void`                 | `voidPlugin` named export + all handler/type re-exports                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| `void`                 | `voidPlugin`, handler/type re-exports, `defer`, `Deferred`, `DeferredState`, `InferProps`, `HeadDescriptor`                                                                                                                                                                                                                                                                                                                                                                                                              |
 | `void/handler`         | `defineHandler`, `defineMiddleware`, `defineScheduled`, `defineQueue`, `defineRender`, `defineHead`, types                                                                                                                                                                                                                                                                                                                                                                                                               |
 | `void/auth`            | `defineAuth`, `getUser`, `getSession`, `requireAuth`, `AuthUser`, `AuthSession`, `AuthState`                                                                                                                                                                                                                                                                                                                                                                                                                             |
 | `void/client`          | `fetch`, `fetchStream`, `FetchError`, `auth`, `createAuthClient`, `AuthUser`, `AuthSession`, `AuthState`                                                                                                                                                                                                                                                                                                                                                                                                                 |
@@ -917,9 +1102,15 @@ Solid `Link` GET `data` is merged into the rendered `href` query string. Primiti
 | `void/drizzle-arktype` | Re-exports [`drizzle-arktype`](https://orm.drizzle.team/docs/arktype) for schema-derived ArkType validators for Drizzle tables                                                                                                                                                                                                                                                                                                                                                                                           |
 | `void/schema-d1`       | Re-exports [`drizzle-orm/sqlite-core`](https://orm.drizzle.team/docs/column-types/sqlite) for D1 table and column builders                                                                                                                                                                                                                                                                                                                                                                                               |
 | `void/schema-pg`       | Re-exports [`drizzle-orm/pg-core`](https://orm.drizzle.team/docs/column-types/pg) for PostgreSQL table and column builders                                                                                                                                                                                                                                                                                                                                                                                               |
-| `void/db`              | `db` ([Drizzle D1](https://orm.drizzle.team/docs/get-started/d1-new) instance), `createDb`, query operators (`eq`, `and`, `or`, `desc`, `like`, `inArray`, etc.)                                                                                                                                                                                                                                                                                                                                                         |
+| `void/db`              | `db` (Drizzle D1 or PostgreSQL instance for the active dialect), `createDb`, query operators (`eq`, `and`, `or`, `desc`, `like`, `inArray`, etc.)                                                                                                                                                                                                                                                                                                                                                                        |
 | `void/seed`            | `defineSeed`, `SeedContext`, `SeedFn` for programmatic `void db seed` modules                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| `void/kv`              | `kv`, `createKV`, typed KV client/map types                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
+| `void/storage`         | `storage`, `createStorage` for the inferred R2 binding or a specific `R2Bucket`                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `void/ai`              | `ai`, `VoidAi`, model input and response types                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| `void/isr`             | `revalidate(options)` for on-demand ISR cache invalidation                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
+| `void/log`             | `logger` structured logging helper                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
 | `void/routes`          | `RouteMap` and `WebSocketRouteMap` stubs (types only)                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
 | `void/queues`          | `queues` proxy for sending messages to typed queues                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
 | `void/sandbox`         | `getSandbox`, `sandbox`, `Sandbox`, and sandbox option types from the Cloudflare Sandbox SDK. `getSandbox(id)` resolves to the same Durable Object instance for a given `id` across all deploys and rollbacks. DO-level storage (`ctx.storage`) is durable; the container filesystem, processes, and exposed ports are tied to a single container lifetime and are lost on idle (`sleepAfter`, default `10m`), crash, or platform restart. See [Sandboxes › State persistence](../guide/sandboxes.md#state-persistence). |
-| `void/env`             | Global Cloudflare env types (types only)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| `void/env`             | `defineEnv`, `env`, schema helpers (`string`, `number`, `boolean`, `url`, `email`, `oneOf`, `json`), and global Cloudflare env types                                                                                                                                                                                                                                                                                                                                                                                     |
+| `void/sveltekit`       | SvelteKit integration helpers: `withVoidTSConfig()` and `mergeVoidSvelteKitTsconfig()`                                                                                                                                                                                                                                                                                                                                                                                                                                   |