void 0.22.0 → 0.23.0

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

@@ -0,0 +1,254 @@
+---
+outline: deep
+---
+
+# Handlers and Middleware {#handlers}
+
+Imported from `"void"` or `"void/handler"`.
+
+## `defineHandler(handler)` {#definehandler-handler}
+
+Wraps a route handler function. The handler receives a [`CloudContext`](./types.md#cloudcontext) and can return a plain value (auto-converted to a Response) or use the Hono `c.json()` / `c.text()` APIs directly.
+
+```ts
+import { defineHandler } from 'void';
+
+export const GET = defineHandler((c) => {
+  return { message: 'hello' };
+});
+```
+
+**Signature:**
+
+```ts
+function defineHandler<R>(handler: (c: CloudContext) => R): TypedHandler<{}, R>;
+```
+
+## `defineHandler(middleware..., handler)` {#definehandler-middleware-handler}
+
+Composes up to 5 per-route middleware with a final handler. Middleware runs in order before the handler.
+
+```ts
+export const GET = defineHandler(authMiddleware, rateLimiter, (c) => {
+  return { ok: true };
+});
+```
+
+## `defineHandler.withValidator(validators)` {#definehandler-withvalidator-validators}
+
+Creates a handler with input validation using any [Standard Schema](https://github.com/standard-schema/standard-schema) compatible library (zod, valibot, arktype, etc.). Returns a curried function that accepts the handler.
+
+Validated input is passed as the second argument to the handler.
+
+```ts
+import { defineHandler } from 'void';
+import * as v from 'valibot';
+
+export const POST = defineHandler.withValidator({
+  body: v.object({
+    name: v.pipe(v.string(), v.minLength(1)),
+    email: v.pipe(v.string(), v.email()),
+  }),
+})((c, { body }) => {
+  return { received: body.name };
+});
+```
+
+**Signature:**
+
+```ts
+function withValidator<V extends ValidatorSlots>(
+  validators: V,
+): <R>(handler: (c: CloudContext, input: HandlerInput<V>) => R) => TypedHandler<V, R>;
+```
+
+**Type: `ValidatorSlots`**
+
+```ts
+interface ValidatorSlots {
+  body?: StandardSchemaV1;
+  query?: StandardSchemaV1;
+  params?: StandardSchemaV1;
+}
+```
+
+**Type: `HandlerInput<V>`**
+
+The inferred output types of each validator slot. For a `ValidatorSlots` with `body` and `query`, the input object has `{ body: ..., query: ... }` with types inferred from the schema output.
+
+## `defineMiddleware(handler)` {#definemiddleware-handler}
+
+Type-safe wrapper for Hono middleware.
+
+```ts
+import { defineMiddleware } from 'void';
+
+export default defineMiddleware(async (c, next) => {
+  console.log(`${c.req.method} ${c.req.path}`);
+  await next();
+});
+```
+
+**Signature:**
+
+```ts
+function defineMiddleware(handler: MiddlewareHandler<CloudEnv>): MiddlewareHandler<CloudEnv>;
+```
+
+## `basicAuth(options)` {#basicauth-options}
+
+Built-in Basic authentication middleware for temporary site gates and pre-launch protection. Use it from `middleware/` with credentials from `void/env` to protect the whole app, or pass it to `defineHandler()` for a single route.
+
+Void’s reserved `/__void` endpoints use their own authentication and are excluded from Basic auth.
+
+When credentials come from `void/env`, wrap the reads in functions so they are resolved per request after Void has bound the runtime env.
+
+For app-specific bypasses such as health checks or public webhooks, compose that logic in your own middleware before calling `basicAuth()`.
+
+```ts
+// env.ts
+import { defineEnv, string } from 'void/env';
+
+export default defineEnv({
+  BASIC_AUTH_USERNAME: string(),
+  BASIC_AUTH_PASSWORD: string(),
+});
+```
+
+```ts
+// middleware/01.basic-auth.ts
+import { basicAuth } from 'void';
+import { env } from 'void/env';
+
+export default basicAuth({
+  username: () => env.BASIC_AUTH_USERNAME,
+  password: () => env.BASIC_AUTH_PASSWORD,
+  realm: 'Preview',
+});
+```
+
+**Signature:**
+
+```ts
+function basicAuth(options: {
+  username: string | (() => string);
+  password: string | (() => string);
+  realm?: string | (() => string);
+  message?: string | (() => string);
+}): MiddlewareHandler<CloudEnv>;
+```
+
+## `defineScheduled(handler)` {#definescheduled-handler}
+
+Wraps a Cloudflare [Scheduled handler](https://developers.cloudflare.com/workers/runtime-apis/handlers/scheduled/) with type inference.
+
+```ts
+import { defineScheduled } from 'void';
+
+export default defineScheduled(async (controller, env, ctx) => {
+  const { results } = await env.DB.prepare('SELECT * FROM stale').all();
+  // ...
+});
+```
+
+**Signature:**
+
+```ts
+function defineScheduled(
+  handler: (
+    controller: ScheduledController,
+    env: CloudEnv['Bindings'],
+    ctx: ExecutionContext,
+  ) => unknown | Promise<unknown>,
+): ScheduledFn;
+```
+
+## `defineQueue<T>(handler)` {#definequeue-t-handler}
+
+Wraps a [queue](../../guide/queues.md) consumer handler with typed message bodies. The generic `<T>` defines the message body type, which flows through to the typed `queues` proxy for `send()` calls.
+
+```ts
+import { defineQueue } from 'void';
+
+export default defineQueue<{ to: string; subject: string }>(async (batch, env) => {
+  for (const msg of batch.messages) {
+    console.log(`Send to ${msg.body.to}: ${msg.body.subject}`);
+  }
+});
+```
+
+**Signature:**
+
+```ts
+function defineQueue<T>(
+  handler: (batch: QueueBatch<T>, env: CloudEnv['Bindings']) => void | Promise<void>,
+): QueueFn;
+```
+
+## `defineRender(handler)` {#definerender-handler}
+
+Wraps an SSR render entry. The second argument provides pre-built `<head>` and `<body>` asset tags for injecting client scripts and styles.
+
+```ts
+import { defineRender } from "void";
+import { renderToString } from "react-dom/server";
+
+export default defineRender((c, assetTags) => {
+  const html = renderToString(<App />);
+  return c.html(`<!DOCTYPE html>
+    <html><head>${assetTags.css}${assetTags.preloads}</head>
+    <body><div id="root">${html}</div>${assetTags.body}</body></html>`);
+});
+```
+
+**Signature:**
+
+```ts
+function defineRender(
+  handler: (c: CloudContext, assetTags: RenderAssetTags) => Response | Promise<Response>,
+): RenderFn;
+```
+
+**Type: `RenderAssetTags`**
+
+```ts
+interface RenderAssetTags {
+  css: string; // Stylesheet links for <head>
+  preloads: string; // Modulepreload and dev client tags for <head>
+  body: string; // Script tags for before </body>
+}
+```
+
+## `defineHead<P>(handler)` {#definehead-p-handler}
+
+Type-safe wrapper for the page `head()` export in `.server.ts` files. Provides [`CloudContext`](./types.md#cloudcontext) typing for the first argument and generic props typing for the second.
+
+```ts
+import { defineHandler, defineHead } from 'void';
+import type { InferProps } from 'void';
+
+export type Props = InferProps<typeof loader>;
+
+export const loader = defineHandler(async (c) => {
+  const post = await getPost(c.req.param('slug'));
+  return { post };
+});
+
+export const head = defineHead<Props>((c, props) => {
+  return {
+    title: props.post.title,
+    meta: [
+      { name: 'description', content: props.post.excerpt },
+      { property: 'og:title', content: props.post.title },
+    ],
+  };
+});
+```
+
+**Signature:**
+
+```ts
+function defineHead<P = Record<string, unknown>>(
+  handler: (c: CloudContext, props: P) => HeadDescriptor | undefined,
+): (c: CloudContext, props: P) => HeadDescriptor | undefined;
+```

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

@@ -0,0 +1,241 @@
+---
+outline: deep
+---
+
+# Pages Adapters {#framework-adaptors}
+
+Framework adaptors for [Pages Routing](../../guide/pages-routing/overview). Each adaptor provides a Vite plugin and client-side runtime.
+
+## `@void/vue` {#void-vue}
+
+### `voidVue(options?)` {#voidvue-options}
+
+Imported from `"@void/vue/plugin"`. Returns an array of Vite plugins that handle Vue SFC compilation and SSR or hydration entry generation. It already includes `@vitejs/plugin-vue`, so you do not need to install or configure that separately.
+
+```ts
+import { voidVue } from '@void/vue/plugin';
+
+export default defineConfig({
+  plugins: [voidPlugin(), voidVue()],
+});
+```
+
+**Signature:**
+
+```ts
+function voidVue(options?: VoidVueOptions): Plugin[];
+```
+
+**Options:**
+
+```ts
+interface VoidVueOptions {
+  vue?: VuePluginOptions; // passed through to @vitejs/plugin-vue
+  viewTransitions?: boolean; // enable View Transitions API for navigations
+}
+```
+
+### Vue Runtime {#vue-runtime}
+
+Imported from `"@void/vue"`.
+
+| Export                             | Description                                                                                                                                                                                                                                       |
+| ---------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `Link`                             | Vue 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`. |
+| `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.                                                                                                                                                                               |
+| `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.
+
+Vue GET navigation remounts the page so `useForm()` picks up the destination record's URL and defaults; layouts persist. Mutations and `router.refresh()` preserve page state by default. Set `preserveState` explicitly to override the default for navigation within the same record.
+
+## `@void/react` {#void-react}
+
+### `voidReact(options?)` {#voidreact-options}
+
+Imported from `"@void/react/plugin"`. Returns an array of Vite plugins that handle SSR and hydration entry generation. It already includes `@vitejs/plugin-react`, so you do not need to install or configure that separately.
+
+```ts
+import { voidReact } from '@void/react/plugin';
+
+export default defineConfig({
+  plugins: [voidPlugin(), voidReact()],
+});
+```
+
+**Signature:**
+
+```ts
+function voidReact(options?: VoidReactOptions): Plugin[];
+```
+
+**Options:**
+
+```ts
+interface VoidReactOptions {
+  react?: ReactPluginOptions; // passed through to @vitejs/plugin-react
+  viewTransitions?: boolean; // enable View Transitions API for navigations
+  prefetch?: {
+    hoverDelay?: number;
+    cacheFor?: number | string | [string, string];
+  };
+}
+```
+
+### React Runtime {#react-runtime}
+
+Imported from `"@void/react"`.
+
+| Export                             | Description                                                                                                                                                                                                                                         |
+| ---------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `Link`                             | React 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`. |
+| `useRouter()`                      | Returns the Void Router with current route state (`url`, `path`, `query`, `params`) and navigation methods: `visit`, `refresh`, awaitable `prefetch`, `flush`, `flushAll`. React navigations are scheduled as transitions.                          |
+| `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()`.                                                                                                                                                  |
+
+React `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.
+
+React deferred props returned from `defer()` are Suspense resources. Read them
+with React's `use()` inside a `<Suspense>` boundary. React Pages requires React
+19 and uses streaming SSR for the initial deferred shell. Rejections throw from
+`use()`, so use a normal React error boundary for custom deferred error UI. Vue,
+Svelte, and Solid keep the `{ loading, value, error }` deferred state object.
+When explicitly annotating props, import `Deferred` from the framework adapter
+package (`@void/react`, `@void/vue`, `@void/svelte`, or `@void/solid`) so the
+type matches that adapter's client runtime shape.
+
+## `@void/svelte` {#void-svelte}
+
+### `voidSvelte(options?)` {#voidsvelte-options}
+
+Imported from `"@void/svelte/plugin"`. Returns an array of Vite plugins that handle SSR and hydration entry generation for Svelte 5. It already includes `@sveltejs/vite-plugin-svelte`, so you do not need to install or configure that separately.
+
+```ts
+import { voidSvelte } from '@void/svelte/plugin';
+
+export default defineConfig({
+  plugins: [voidPlugin(), voidSvelte()],
+});
+```
+
+**Signature:**
+
+```ts
+function voidSvelte(options?: VoidSvelteOptions): Plugin[];
+```
+
+**Options:**
+
+```ts
+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];
+  };
+}
+```
+
+### Svelte Runtime {#svelte-runtime}
+
+Imported from `"@void/svelte"`.
+
+| Export                             | Description                                                                                                                                                                                                                                          |
+| ---------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `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.                                                                                                                                                                                  |
+| `useNavigation()`                  | Returns pending navigation state: `{ state, location, method }`, where `state` is `"idle"`, `"loading"`, or `"submitting"` and `location` is the pending destination.                                                                                |
+
+Svelte `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.
+
+## `@void/solid` {#void-solid}
+
+### `voidSolid(options?)` {#voidsolid-options}
+
+Imported from `"@void/solid/plugin"`. Returns an array of Vite plugins that handle SSR and hydration entry generation for Solid. It already includes `vite-plugin-solid`, so you do not need to install or configure that separately.
+
+```ts
+import { voidSolid } from '@void/solid/plugin';
+
+export default defineConfig({
+  plugins: [voidPlugin(), voidSolid()],
+});
+```
+
+**Signature:**
+
+```ts
+function voidSolid(options?: VoidSolidOptions): Plugin[];
+```
+
+**Options:**
+
+```ts
+interface VoidSolidOptions {
+  solid?: SolidPluginOptions; // passed through to vite-plugin-solid
+  viewTransitions?: boolean; // enable View Transitions API
+  prefetch?: {
+    hoverDelay?: number;
+    cacheFor?: number | string | [string, string];
+  };
+}
+```
+
+### Solid Runtime {#solid-runtime}
+
+Imported from `"@void/solid"`.
+
+| Export                             | Description                                                                                                                                                                                                                                         |
+| ---------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `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.                                                                                                                                                                                 |
+| `useNavigation()`                  | Returns pending navigation state: `{ state, location, method }`, where `state` is `"idle"`, `"loading"`, or `"submitting"` and `location` is the pending destination.                                                                               |
+
+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.
+
+## Markdown Package {#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.
+
+## Form
+
+Each Pages adapter exports `Form`. Pass the object returned by `useForm()` as `form`; `method` defaults to `post`. It renders validation and action errors, preserves controlled input, and respects known quota retry deadlines without submitting automatically. `renderError` customizes action-error presentation; Svelte uses a snippet. See [Actions and Forms](../../guide/pages-routing/actions-and-forms.md).

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

@@ -0,0 +1,39 @@
+---
+outline: deep
+---
+
+# Plugin and Configuration {#plugin}
+
+## `voidPlugin(options?)` {#voidplugin-options}
+
+Named export from `"void"`. Returns an array of Vite plugins that set up file-based routing, migration support, and the Cloudflare Workers runtime. Application-level configuration is read from [`void.config.ts`](../config.md); the optional `options` object controls Vite/Cloudflare plugin behavior.
+
+```ts
+import { voidPlugin } from 'void';
+
+export default defineConfig({
+  plugins: [voidPlugin()],
+});
+```
+
+| Option             | Type                      | Description                                                                                                                                                                                                                       |
+| ------------------ | ------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `persistTo`        | `string`                  | Directory path for persisting local dev state (D1, KV, R2). Defaults to `.void/` in the project root.                                                                                                                             |
+| `auxiliaryWorkers` | `AuxiliaryWorkerConfig[]` | Additional workers to run inside the same Miniflare instance during dev. Passed through to `@cloudflare/vite-plugin`. Useful for running multiple workers that share bindings (e.g. a separate API worker alongside a dashboard). |
+
+## Project configuration {#project-configuration}
+
+### `defineConfig(config)` {#defineconfig-config}
+
+Import from `void/config` in the root `void.config.ts`. It returns the config with editor completion and TypeScript checking. Void validates the result when loading it, including values computed at runtime.
+
+```ts
+import { defineConfig } from 'void/config';
+
+export default defineConfig({
+  cloudflare: { name: 'my-app' },
+  routing: { revalidate: 60 },
+});
+```
+
+See the [config reference](../config.md) for all fields.

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

@@ -0,0 +1,109 @@
+---
+outline: deep
+---
+
+# Resource Clients
+
+## KV {#kv}
+
+Imported from `"void/kv"`.
+
+### `kv` {#kv-1}
+
+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 {#storage}
+
+Imported from `"void/storage"`.
+
+### `storage` {#storage-1}
+
+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 {#ai}
+
+Imported from `"void/ai"`.
+
+### `ai` {#ai-1}
+
+Typed AI client for Cloudflare AI models and provider-native AI Gateway requests.
+
+```ts
+import { ai } from 'void/ai';
+
+const result = await ai
+  .run('@cf/meta/llama-3.3-70b-instruct-fp8-fast', {
+    messages: [{ role: 'user', content: 'Summarize this release note.' }],
+  })
+  .match({ ok: (result) => result, limited: (limit) => limit.response() });
+
+const response = await ai
+  .provider('openai')
+  .fetch('/chat/completions', {
+    body: {
+      model: 'gpt-4o',
+      messages: [{ role: 'user', content: 'Summarize this release note.' }],
+    },
+  })
+  .match({ ok: (result) => result, limited: (limit) => limit.response() });
+```
+
+**Key exports:** `ai`, `VoidAi`, provider request types. See [AI](../../guide/ai.md) for provider setup and streaming examples.
+
+## ISR {#isr}
+
+Imported from `"void/isr"`.
+
+### `revalidate(options)` {#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 {#logging}
+
+Imported from `"void/log"`.
+
+### `logger` {#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?)`.