void 0.25.0 → 0.26.1

package/{skills/void/docs → docs}/guide/sandboxes.md

@@ -18,13 +18,10 @@ import { getSandbox } from 'void/sandbox';
 
 export const POST = defineHandler(async (c) => {
   const sandbox = await getSandbox('default');
-  return sandbox.run(['node', '--version']).match({
-    ok: (result) =>
-      c.json({
-        exitCode: result.exitCode,
-        stdout: new TextDecoder().decode(result.stdout),
-      }),
-    limited: (limit) => limit.response({ message: 'Execution is temporarily unavailable.' }),
+  const result = await sandbox.run(['node', '--version']);
+  return c.json({
+    exitCode: result.exitCode,
+    stdout: new TextDecoder().decode(result.stdout),
   });
 });
 ```
@@ -42,33 +39,55 @@ const sandbox = await getSandbox(`user-${user.id}`, {
   inactivityTimeoutMs: 10 * 60 * 1000,
   enableInternet: false,
 });
-const response = await sandbox
-  .run(['node', '--version'], {
-    signal: AbortSignal.timeout(5_000),
-  })
-  .match({
-    ok: (result) => Response.json({ exitCode: result.exitCode }),
-    limited: (limit) => limit.response(),
-  });
+const result = await sandbox.run(['node', '--version'], {
+  signal: AbortSignal.timeout(5_000),
+});
 ```
 
 Commands take an executable and arguments as an array. For shell syntax, explicitly run `['sh', '-c', command]`. Execution options include `cwd` (default `/workspace`), `env`, `user`, `signal`, `pty`, `stdin`, `stdout`, and `stderr`.
 
-`run()` collects command output and handles limits throughout execution with one required `.match({ ok, limited })`. Both handlers are required. Other failures still reject.
+Sandbox operations return promises. `run()` resolves with `stdout` and `stderr` as `ArrayBuffer`s and the command's exit code. Usage limits reject with [`UsageLimit`](#usage-limits); other failures reject normally.
 
-`exec()` returns a lazy operation yielding a process through its `ok` handler. Use `output()` to collect `stdout` and `stderr` as `ArrayBuffer`s with the exit code, or read the streams and match `exitCode`. Both `output()` and `exitCode` require their own `.match({ ok, limited })`. Matching `exitCode` keeps a long command active during pauses in its output; unattended background commands can stop when the Sandbox becomes idle.
+`exec()` resolves with a process. Await `process.output()` to collect its output and exit code, or read the streams and await `process.exitCode`. Waiting for completion keeps a long command active during pauses in its output; unattended background commands can stop when the Sandbox becomes idle. A runtime limit can reject completion after a command has successfully started.
 
 Use `stdin: 'pipe'` for a writable input stream. `kill(signal?)` stops a process, and `resize(cols, rows)` resizes its terminal.
 
-File operations live under `sandbox.files`: `readFile`, `writeFile`, `stat`, `lstat`, `readDirectory`, `mkdir`, `rename`, and `remove`. Each file operation requires `.match({ ok, limited })`. `readFile()` yields a streaming `Response` to `ok`; use `.text()`, `.arrayBuffer()`, or `.body`. `writeFile()` accepts text, binary data, or a byte stream. Relative file paths require an explicit `cwd` option.
+File operations live under `sandbox.files`: `readFile`, `writeFile`, `stat`, `lstat`, `readDirectory`, `mkdir`, `rename`, and `remove`. Await `readFile()` to receive a streaming `Response`, then use `.text()`, `.arrayBuffer()`, or `.body`. `writeFile()` accepts text, binary data, or a byte stream. Relative file paths require an explicit `cwd` option.
 
-To reach a server inside the container, call `sandbox.fetch(port, new Request(url)).match({ ok, limited })`. `sandbox.running()` checks whether the container is running; `sandbox.destroy()` stops it.
+To reach a server inside the container, await `sandbox.fetch(port, new Request(url))`. `sandbox.running()` checks whether the container is running; `sandbox.destroy()` stops it.
 
 `getSandbox()` options include `inactivityTimeoutMs` (default ten minutes, maximum six hours), `enableInternet` (default `false`), and string `labels`. Internet access and labels take effect on the next container start. `binding` selects a custom native binding; managed platforms use the configured binding.
 
 For code that runs on both deployment targets, use `getSandbox()`. Direct access through `c.env.SANDBOX` is available only on local and native Cloudflare deployments.
 
-The `limited` handler receives `resource: 'sandbox'`, a `reason` of `concurrency` or `runtime_budget`, and `response({ message })` for a structured HTTP 429. Keep user input available so it can be retried. Resolving a Sandbox, checking `running()`, stopping a process, and `destroy()` do not need a quota handler; cleanup remains available after a limit.
+## Usage limits
+
+Sandbox limits reject with `SandboxLimitError`, which extends `UsageLimit` from `void/limits`. The error includes `resource: 'sandbox'` and a `reason` of `concurrency` or `runtime_budget`. Void route handlers and Pages actions automatically send a structured HTTP 429 when the error is left uncaught.
+
+Use `instanceof UsageLimit` to optionally handle both AI and Sandbox limits, or `instanceof SandboxLimitError` for Sandbox-specific handling:
+
+```ts
+import { defineHandler } from 'void';
+import { UsageLimit } from 'void/limits';
+import { getSandbox } from 'void/sandbox';
+
+export const POST = defineHandler(async (c) => {
+  const sandbox = await getSandbox('default');
+  try {
+    const result = await sandbox.run(['node', 'task.mjs']);
+    return c.json({ exitCode: result.exitCode });
+  } catch (error) {
+    if (error instanceof UsageLimit) {
+      return error.response({
+        message: 'Execution is temporarily unavailable. Try again shortly.',
+      });
+    }
+    throw error;
+  }
+});
+```
+
+Keep user input available so it can be retried. Checking `running()`, stopping a process, and `destroy()` remain available after a usage limit.
 
 ## State persistence
 
@@ -78,7 +97,7 @@ Files, running processes, and listening servers last only as long as the contain
 
 ## Configuration
 
-The default environment provides Node.js 24 on Debian Trixie. Managed platform deploys use Cloudflare's managed Node.js image.
+The default environment provides Node.js 26 on Debian Trixie. Managed platform deploys use Cloudflare's managed Node.js image.
 
 Use `void.config.ts` when you need a custom image or container size:
 
@@ -99,7 +118,7 @@ See the [configuration reference](../reference/config.md#sandbox) for binding na
 Custom images must include the helper matching Void's installed Sandbox SDK version. The SDK image supplies this binary, but is not a runnable environment itself:
 
 ```dockerfile
-FROM node:24.21.0-trixie-slim
+FROM node:26.10.0-trixie-slim
 COPY --from=docker.io/cloudflare/sandbox:1.0.0 /usr/local/bin/sandbox-shim /usr/local/bin/sandbox-shim
 WORKDIR /workspace
 CMD ["sleep", "infinity"]

package/{skills/void/docs → docs}/guide/sse.md

@@ -168,6 +168,4 @@ export const GET = defineHandler(async (c) => {
 });
 ```
 
-Native `EventSource` can send cookies with `withCredentials: true`. For non-cookie auth, generate a short-lived signed URL and validate it in the route handler.
-
 For shared topics and subscriptions, use [Live Event Streams](./live.md). For two-way communication, use [WebSockets](./websockets.md).

package/{skills/void/docs → docs}/guide/storage.md

@@ -42,12 +42,12 @@ const head = await storage.head('uploads/photo.jpg');
 A common pattern is serving uploaded files from an API route:
 
 ```ts
+// routes/files/[key].ts
 import { defineHandler } from 'void';
 import { storage } from 'void/storage';
 
 export const GET = defineHandler(async (c) => {
-  const key = c.req.param('key');
-  const object = await storage.get(key);
+  const object = await storage.get(`uploads/${c.req.param('key')}`);
 
   if (!object) {
     return c.notFound();
@@ -56,11 +56,16 @@ export const GET = defineHandler(async (c) => {
   const headers = new Headers();
   object.writeHttpMetadata(headers);
   headers.set('etag', object.httpEtag);
+  // Don't let an uploaded HTML or SVG file run as a page on your site.
+  headers.set('X-Content-Type-Options', 'nosniff');
+  headers.set('Content-Disposition', 'attachment');
 
   return new Response(object.body, { headers });
 });
 ```
 
+Files your users upload can contain HTML or scripts. Store them under keys your server picks, and serve them with `nosniff` and `Content-Disposition: attachment`. `<img>` and `<video>` tags still display them; opening the URL directly downloads the file.
+
 ## Custom bindings
 
 Use `createStorage(bucket)` with your own R2 binding, or in tests:

package/{skills/void/docs → docs}/guide/websockets.md

@@ -151,6 +151,10 @@ Messages are JSON events. Raw string and binary messages are not supported.
 
 When Void auth is enabled, every WebSocket hook receives the current user as `ctx.user`, or `null` for an anonymous connection. Use `onBeforeConnect` to reject unauthenticated clients.
 
+Connections from another origin are anonymous unless that origin is in your auth `trustedOrigins`. If you read your own cookies from `ctx.request`, check its `Origin` header yourself.
+
+`ctx.user` is resolved when the socket connects and stays the same for that connection, even if the user later signs out or the session is revoked. For actions that must respect a ban or role change, re-check your own records in `onMessage` and close the connection with `ctx.connection.close()` in rooms or `ctx.socket.close()` in `defineWebSocket()`.
+
 ## Hooks
 
 Both `defineRoom()` and `defineWebSocket()` support:

package/docs/integrations/agents.md

@@ -0,0 +1,37 @@
+---
+outline: deep
+---
+
+# Using Void with Coding Agents
+
+`void init` sets up coding agents as part of project initialization:
+
+```sh
+npx void init
+```
+
+New projects get a minimal `AGENTS.md` explaining Void and where to read its docs.
+In an existing project, Void asks before creating, appending to, or updating
+`AGENTS.md`. It preserves your instructions outside the Void section. Declining
+keeps the file unchanged; CI and non-interactive runs skip changes to existing
+projects' instructions.
+
+The complete Markdown docs ship at `node_modules/void/docs/`. Start with
+`guide/quickstart.md` for setup and `reference/cli.md` for commands. Agents can
+read them directly, even without a linked skill.
+
+## Skills
+
+Skills point your agent to the commands and docs it needs for the task. They link to the installed `void` package, so the guidance matches the version your app uses.
+
+Void ships two skills:
+
+- **`void`:** commands and docs for app development.
+- **`migrate-vite-cloudflare-to-void`:** migration skill for converting existing `@cloudflare/vite-plugin` apps to Void.
+
+Skills are linked automatically by `void init` when it detects a supported
+agent's configuration. For example, Claude Code uses `.claude/skills/` and Codex
+uses `.agents/skills/`. The skills use the app's installed docs so their guidance
+matches its Void version. Globally installed skills can use the docs in their
+Void package when there is no local installation. If no agent is detected, the
+instructions still point directly to the bundled docs.

package/{skills/void/docs → docs}/integrations/frameworks/astro.md

@@ -10,7 +10,7 @@ Use Void with [Astro](https://astro.build/) for resource detection, typed databa
 
 - [Astro 6+](https://astro.build/blog/astro-6/) is required to use `import { x } from "void/x"` helpers in Astro apps.
 - You also need to enable `"nodejs_als"` under `compatibility_flags` in your Cloudflare config.
-  :::
+:::
 
 ## Setup
 
@@ -30,8 +30,8 @@ npm install -D @astrojs/cloudflare void
 ### 3. Configure `astro.config.mjs`
 
 ```js
-import { defineConfig } from 'astro/config';
 import cloudflare from '@astrojs/cloudflare';
+import { defineConfig } from 'astro/config';
 import { voidPlugin } from 'void';
 
 export default defineConfig({
@@ -85,9 +85,9 @@ export const prerender = false;
 Use `void/db` in API routes and server-side code:
 
 ```ts
+import { users } from '@schema';
 import type { APIRoute } from 'astro';
 import { db } from 'void/db';
-import { users } from '@schema';
 
 export const GET: APIRoute = async () => {
   const rows = await db.select().from(users);

package/{skills/void/docs → docs}/integrations/frameworks/nuxt.md

@@ -33,10 +33,14 @@ export default defineNuxtConfig({
   nitro: {
     preset: 'cloudflare-module',
     cloudflareDev: { configPath: './.void-wrangler.jsonc' },
+    // Required for Nuxt 4.6.0 on Windows.
+    externals: {
+      inline: [/[\\/]node_modules[\\/]nuxt[\\/]dist[\\/]/],
+    },
     alias: {
       // Nitro has its own bundler that doesn't use Vite aliases.
       // Duplicate @schema here so Nitro can resolve it.
-      '@schema': resolve(__dirname, 'db/schema.ts'),
+      '@schema': resolve(import.meta.dirname, 'db/schema.ts'),
     },
   },
   vite: { plugins: [voidPlugin()] },
@@ -75,9 +79,9 @@ Void-managed auth is not supported in framework mode yet. Use Better Auth's offi
 ### Database
 
 ```ts
+import { users } from '@schema';
 // server/api/users.get.ts
 import { db } from 'void/db';
-import { users } from '@schema';
 
 export default defineEventHandler(async () => {
   return db.select().from(users);

package/{skills/void/docs → docs}/integrations/hono.md

@@ -17,25 +17,33 @@ Once `hono` is installed in your app, you can use built-in middleware, helpers,
 Use Hono's built-in middleware in your global middleware files or per-route:
 
 ```ts
+import { cors } from 'hono/cors';
 // middleware/01.cors.ts
 import { defineMiddleware } from 'void';
-import { cors } from 'hono/cors';
 
 export default defineMiddleware(cors({ origin: 'https://example.com' }));
 ```
 
 ```ts
-// middleware/02.cache.ts
-import { defineMiddleware } from 'void';
 import { cache } from 'hono/cache';
+// routes/api/products.ts (per-route cache)
+import { defineHandler } from 'void';
+import { listProducts } from '../../lib/products';
 
-export default defineMiddleware(cache({ cacheName: 'my-app', cacheControl: 'max-age=3600' }));
+export const GET = defineHandler(
+  cache({ cacheName: 'products', cacheControl: 'max-age=3600' }),
+  async () => ({ products: await listProducts() }),
+);
 ```
 
+::: warning
+`cache()` stores one response per URL and returns it to every visitor. It skips requests with an `Authorization` header, but not cookies. Use it only on routes whose response is the same for everyone, never on a route that reads the signed-in user. To cache pages, use [revalidation](../guide/edge/revalidation.md), which skips requests that carry a cookie.
+:::
+
 ```ts
+import { bearerAuth } from 'hono/bearer-auth';
 // routes/api/webhooks/stripe.ts (per-route usage)
 import { defineHandler } from 'void';
-import { bearerAuth } from 'hono/bearer-auth';
 
 export const POST = defineHandler(bearerAuth({ token: 'webhook-secret' }), async (c) => {
   const body = await c.req.json();
@@ -48,9 +56,9 @@ export const POST = defineHandler(bearerAuth({ token: 'webhook-secret' }), async
 Hono's context helpers are available on `c` in every handler:
 
 ```ts
+import { stream } from 'hono/streaming';
 // routes/api/download.ts
 import { defineHandler } from 'void';
-import { stream } from 'hono/streaming';
 
 export const GET = defineHandler((c) => {
   return stream(c, async (stream) => {
@@ -76,9 +84,9 @@ export const GET = defineHandler((c) => {
 Any `hono/*` or `@hono/*` package works. Install the package in your app, then use it directly:
 
 ```ts
+import { rateLimiter } from 'hono-rate-limiter';
 // middleware/01.rate-limit.ts
 import { defineMiddleware } from 'void';
-import { rateLimiter } from 'hono-rate-limiter';
 
 export default defineMiddleware(rateLimiter({ windowMs: 60_000, limit: 100 }));
 ```

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

@@ -111,6 +111,7 @@ The following imports are **not available** with a non-CF target and produce a c
 | `void/storage` | R2 (blob storage)        |
 | `void/auth`    | Void-managed Better Auth |
 | `void/ai`      | Workers AI               |
+| `void/sandbox` | Cloudflare Sandboxes     |
 | `void/env`     | Typed environment schema |
 
 If you need a database or storage, use an external provider and connect via standard Node.js libraries.

package/{skills/void/docs → docs}/reference/api/auth.md

@@ -4,7 +4,7 @@ outline: deep
 
 # Authentication {#auth}
 
-Imported from `"void"` or `"void/auth"`. Client-side helpers imported from `"void/client"`.
+Imported from `"void/auth"`. Client-side helpers imported from `"void/client"`.
 
 ## `defineAuth(config)` {#defineauth-config}
 

package/{skills/void/docs → docs}/reference/api/handlers.md

@@ -41,8 +41,8 @@ Creates a handler with input validation using any [Standard Schema](https://gith
 Validated input is passed as the second argument to the handler.
 
 ```ts
-import { defineHandler } from 'void';
 import * as v from 'valibot';
+import { defineHandler } from 'void';
 
 export const POST = defineHandler.withValidator({
   body: v.object({
@@ -103,6 +103,8 @@ Void’s reserved `/__void` endpoints use their own authentication and are exclu
 
 When credentials come from `void/env`, wrap the reads in functions so they are resolved per request after Void has bound the runtime env.
 
+If `password` resolves to an empty value, requests fail with a server error instead of passing the gate.
+
 For app-specific bypasses such as health checks or public webhooks, compose that logic in your own middleware before calling `basicAuth()`.
 
 ```ts
@@ -182,7 +184,7 @@ export default defineQueue<{ to: string; subject: string }>(async (batch, env) =
 ```ts
 function defineQueue<T>(
   handler: (batch: QueueBatch<T>, env: CloudEnv['Bindings']) => void | Promise<void>,
-): QueueFn;
+): TypedQueueHandler<T>;
 ```
 
 ## `defineRender(handler)` {#definerender-handler}

package/{skills/void/docs → docs}/reference/api/pages.md

@@ -32,6 +32,10 @@ function voidVue(options?: VoidVueOptions): Plugin[];
 interface VoidVueOptions {
   vue?: VuePluginOptions; // passed through to @vitejs/plugin-vue
   viewTransitions?: boolean; // enable View Transitions API for navigations
+  prefetch?: {
+    hoverDelay?: number;
+    cacheFor?: number | string | [string, string];
+  };
 }
 ```
 

package/{skills/void/docs → docs}/reference/api/resources.md

@@ -51,25 +51,22 @@ 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', {
+const result = await ai.run('@cf/meta/llama-3.3-70b-instruct-fp8-fast', {
+  messages: [{ role: 'user', content: 'Summarize this release note.' }],
+});
+
+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() });
-
-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.
 
+AI methods return promises and reject usage limits with `UsageLimit` from `void/limits`. Void routes and Pages actions return a structured HTTP 429 for uncaught limits. See [usage limits](../../guide/ai.md#usage-limits) for optional `instanceof UsageLimit` handling.
+
 ### Provider keys
 
 Default secret names for `ai.provider()`. Use `apiKeyEnv` to choose another name.

package/{skills/void/docs → docs}/reference/api.md

@@ -33,37 +33,38 @@ Use this reference to find public imports, signatures, and return types. For set
 
 Import Void's app-facing APIs from these paths:
 
-| Import path               | Contents                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
-| ------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `void`                    | `voidPlugin`, handler/type re-exports, `defer`, `Deferred`, `DeferredState`, `InferProps`, `HeadDescriptor`                                                                                                                                                                                                                                                                                                                                                                        |
-| `void/handler`            | `defineHandler`, `defineMiddleware`, `basicAuth`, `defineScheduled`, `defineQueue`, `defineRender`, `defineHead`, types                                                                                                                                                                                                                                                                                                                                                            |
-| `void/auth`               | `defineAuth`, `getUser`, `getSession`, `requireAuth`, `AuthUser`, `AuthSession`, `AuthState`                                                                                                                                                                                                                                                                                                                                                                                       |
-| `void/client`             | `fetch`, `fetchStream`, `FetchError`, `auth`, `createAuthClient`, `AuthUser`, `AuthSession`, `AuthState`                                                                                                                                                                                                                                                                                                                                                                           |
-| `void/client/{framework}` | Same as `void/client`, with framework-specific Better Auth clients for `react`, `vue`, `svelte`, and `solid`                                                                                                                                                                                                                                                                                                                                                                       |
-| `void/ws`                 | `defineRoom`, `defineWebSocket`, `connect`, WebSocket context and connection types                                                                                                                                                                                                                                                                                                                                                                                                 |
-| `void/durable`            | `defineDurableState`, typed state/RPC/context/migration types                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| `void/sse`                | `eventStream`, `formatSse`, `formatSseText`, `getLastEventId`, `SseStreamClosedError`, SSE message and stream types                                                                                                                                                                                                                                                                                                                                                                |
-| `void/sse/client`         | `connectEventStream`, browser `EventSource` wrapper types                                                                                                                                                                                                                                                                                                                                                                                                                          |
-| `void/live`               | `defineLiveStream`, SSE topic fanout runtime types. Server-only.                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| `void/live/client`        | `connectLiveStream`, browser helper for one SSE connection plus POST subscribe/unsubscribe control.                                                                                                                                                                                                                                                                                                                                                                                |
-| `void/response`           | `convertReturnValue`                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
-| `void/validator`          | `runValidation`, `ValidatorSlots`, `HandlerInput`                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| `void/drizzle-zod`        | Re-exports [`drizzle-zod`](https://orm.drizzle.team/docs/zod) for schema-derived Zod validators for Drizzle tables                                                                                                                                                                                                                                                                                                                                                                 |
-| `void/drizzle-valibot`    | Re-exports [`drizzle-valibot`](https://orm.drizzle.team/docs/valibot) for schema-derived Valibot validators for Drizzle tables                                                                                                                                                                                                                                                                                                                                                     |
-| `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/schema-mysql`       | Re-exports `drizzle-orm/mysql-core` for MySQL table and column builders                                                                                                                                                                                                                                                                                                                                                                                                            |
-| `void/database-provider`  | `defineDatabaseProvider` and adapter types for `void db connect --provider`                                                                                                                                                                                                                                                                                                                                                                                                        |
-| `void/db`                 | `db` (Drizzle D1, PostgreSQL, or MySQL 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`, `SandboxLimitError`, `SandboxUnavailableError`, and the SDK 1.0 file, backup, and mount helpers. `getSandbox(id)` resolves a client. Commands, files, port requests and process completion require `.match({ ok, limited })`; `run()` collects output through one matched operation. Container state lasts until inactivity (default ten minutes), a crash, or a restart. See [Sandboxes](../guide/sandboxes.md) for the API and deployment requirements. |
-| `void/env`                | `defineEnv`, `env`, schema helpers (`string`, `number`, `boolean`, `url`, `email`, `oneOf`, `json`), and global Cloudflare env types                                                                                                                                                                                                                                                                                                                                               |
-| `void/sveltekit`          | SvelteKit integration helpers: `withVoidTSConfig()` and `mergeVoidSvelteKitTsconfig()`                                                                                                                                                                                                                                                                                                                                                                                             |
+| Import path               | Contents                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| ------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `void`                    | `voidPlugin`, handler/type re-exports, `defer`, `Deferred`, `DeferredState`, `InferProps`, `HeadDescriptor`                                                                                                                                                                                                                                                                                                                                                                    |
+| `void/handler`            | `defineHandler`, `defineMiddleware`, `basicAuth`, `defineScheduled`, `defineQueue`, `defineRender`, `defineHead`, types                                                                                                                                                                                                                                                                                                                                                        |
+| `void/auth`               | `defineAuth`, `getUser`, `getSession`, `requireAuth`, `AuthUser`, `AuthSession`, `AuthState`                                                                                                                                                                                                                                                                                                                                                                                   |
+| `void/client`             | `fetch`, `fetchStream`, `FetchError`, `auth`, `createAuthClient`, `AuthUser`, `AuthSession`, `AuthState`                                                                                                                                                                                                                                                                                                                                                                       |
+| `void/client/{framework}` | Same as `void/client`, with framework-specific Better Auth clients for `react`, `vue`, `svelte`, and `solid`                                                                                                                                                                                                                                                                                                                                                                   |
+| `void/ws`                 | `defineRoom`, `defineWebSocket`, `connect`, WebSocket context and connection types                                                                                                                                                                                                                                                                                                                                                                                             |
+| `void/durable`            | `defineDurableState`, typed state/RPC/context/migration types                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| `void/sse`                | `eventStream`, `formatSse`, `formatSseText`, `getLastEventId`, `SseStreamClosedError`, SSE message and stream types                                                                                                                                                                                                                                                                                                                                                            |
+| `void/sse/client`         | `connectEventStream`, browser `EventSource` wrapper types                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| `void/live`               | `defineLiveStream`, SSE topic fanout runtime types. Server-only.                                                                                                                                                                                                                                                                                                                                                                                                               |
+| `void/live/client`        | `connectLiveStream`, browser helper for one SSE connection plus POST subscribe/unsubscribe control.                                                                                                                                                                                                                                                                                                                                                                            |
+| `void/response`           | `convertReturnValue`                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| `void/validator`          | `runValidation`, `ValidatorSlots`, `HandlerInput`                                                                                                                                                                                                                                                                                                                                                                                                                              |
+| `void/drizzle-zod`        | Re-exports [`drizzle-zod`](https://orm.drizzle.team/docs/zod) for schema-derived Zod validators for Drizzle tables                                                                                                                                                                                                                                                                                                                                                             |
+| `void/drizzle-valibot`    | Re-exports [`drizzle-valibot`](https://orm.drizzle.team/docs/valibot) for schema-derived Valibot validators for Drizzle tables                                                                                                                                                                                                                                                                                                                                                 |
+| `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/schema-mysql`       | Re-exports `drizzle-orm/mysql-core` for MySQL table and column builders                                                                                                                                                                                                                                                                                                                                                                                                        |
+| `void/database-provider`  | `defineDatabaseProvider` and adapter types for `void db connect --provider`                                                                                                                                                                                                                                                                                                                                                                                                    |
+| `void/db`                 | `db` (Drizzle D1, PostgreSQL, or MySQL 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/limits`             | `UsageLimit`, `UsageLimitData`, and `readUsageLimit`. AI and Sandbox limits reject with `UsageLimit`; uncaught limits in Void routes and Pages actions return structured HTTP 429 responses.                                                                                                                                                                                                                                                                                   |
+| `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`, `SandboxLimitError`, `SandboxUnavailableError`, and the SDK 1.0 file, backup, and mount helpers. `getSandbox(id)` resolves a client. Commands, files, port requests, and process completion return promises; limits reject with `SandboxLimitError`, which extends `UsageLimit`. Container state lasts until inactivity (default ten minutes), a crash, or a restart. See [Sandboxes](../guide/sandboxes.md) for the API and deployment requirements. |
+| `void/env`                | `defineEnv`, `env`, schema helpers (`string`, `number`, `boolean`, `url`, `email`, `oneOf`, `json`), and global Cloudflare env types                                                                                                                                                                                                                                                                                                                                           |
+| `void/sveltekit`          | SvelteKit integration helpers: `withVoidTSConfig()` and `mergeVoidSvelteKitTsconfig()`                                                                                                                                                                                                                                                                                                                                                                                         |

package/{skills/void/docs → docs}/reference/cli/auth.md

@@ -6,13 +6,15 @@ outline: deep
 
 ```sh
 void connect
-void connect https://platform.example.com
+void connect platform.example.com
 void connect --platform cloudflare
 void connect --platform void
 ```
 
 Connect a project to its deployment destination. With no arguments, choose Cloudflare or a Void platform interactively. A URL selects a Void platform directly. `--platform void` offers saved platforms and an option to enter another URL.
 
+You can omit `https://` from a platform URL: `void connect platform.example.com` connects to `https://platform.example.com`. This also works in the interactive prompt. For a local HTTP platform, include the scheme, such as `http://localhost:8787`.
+
 For Cloudflare, Void signs in through the browser when needed, selects an accessible account, and saves `cloudflare.account_id` in `void.config.ts` or resolved state in `void.lock.json`. It shares this setup with `void init`. An existing account selection is preserved; conflicting or inaccessible account settings must be resolved before continuing.
 
 For a Void platform, Void checks the connection and signs you in through your browser when needed. It saves credentials in your system keychain separately for each platform.
@@ -30,11 +32,6 @@ platform. In a non-interactive shell, pass `--platform cloudflare|void` or use
 the explicit `void cloudflare` and `void account` commands. Choosing a destination
 for authentication does not change the project's deploy target.
 
-`void auth whoami`, `void auth link`, and `void auth token` remain supported for
-existing scripts. `whoami` follows the selected destination; `link` and `token`
-are Void account operations. Prefer `void auth status`, `void account link`, and
-`void account token` in new scripts.
-
 ## Void platform account {#void-platform-account}
 
 ### `void account login` {#void-account-login}

package/{skills/void/docs → docs}/reference/cli/database.md

@@ -24,7 +24,7 @@ Show migration status. Displays which migrations are applied or pending locally,
 
 ## `void db reset` {#void-db-reset}
 
-Drop the local D1 database and re-apply all migrations. Does not affect the remote database.
+Drop the development database and re-apply all migrations. D1 resets the local database; PostgreSQL and MySQL drop all tables in the `DATABASE_URL` database from `.env`. Does not affect the deployed database.
 
 ## `void db seed` {#void-db-seed}
 
@@ -79,11 +79,10 @@ Open [Drizzle Studio](https://orm.drizzle.team/docs/drizzle-kit-studio) for the
 
 By default, targets the local database. Pass `--remote` to open Studio against the deployed database:
 
-- **PostgreSQL and MySQL projects**: fetch the stored connection string from the platform and open Studio against it. If the URL isn't stored yet, run `void db set-url` first.
+- **Hosted PostgreSQL and MySQL projects**: fetch the stored connection string from the platform and open Studio against it. If the URL isn't stored yet, run `void db set-url` first.
+- **Direct Cloudflare PostgreSQL and MySQL projects**: use `DATABASE_URL` from the current shell.
 - **D1 projects**: remote Studio is not yet supported. Use `void db execute --remote` for ad-hoc queries against your deployed D1 database.
 
-On direct Cloudflare PostgreSQL/MySQL targets, remote Studio uses `DATABASE_URL` from the current shell. Direct D1 Studio remains unsupported; use `void db execute --remote`.
-
 ## `void db rename-migrations` {#void-db-rename-migrations}
 
 Rename existing migrations from the old numeric prefix format (`0001_name.sql`) to timestamp-based format (`20260410161500_name.sql`). Updates local tracking table and remote records if logged in with a linked project.

package/{skills/void/docs → docs}/reference/cli/generate.md

@@ -109,7 +109,7 @@ void gen cron hourly-sync
 void gen queue <name>
 ```
 
-Create a queue consumer file in `queues/` with `defineQueue`, a `Message` interface, and commented-out batch options.
+Create a queue consumer file in `queues/` with `defineQueue`, a `Message` type, and commented-out batch options.
 
 ```sh
 void gen queue emails