void 0.9.1 → 0.9.3

package/dist/{scan-2YmJkYAf.mjs → scan-VCAM1oh3.mjs}

@@ -1,6 +1,6 @@
 import { a as join, n as dirname, r as extname, t as basename } from "./pathe.M-eThtNZ-BrPhGF_K.mjs";
 import { n as readProjectPaths } from "./project-paths-CCMrHYQm.mjs";
-import { t as glob } from "./dist-DR9sIMbM.mjs";
+import { t as glob } from "./dist-5cGIJHQQ.mjs";
 import { existsSync, readFileSync } from "node:fs";
 //#region src/router/parse-filename.ts
 const EXTENSIONS = [
@@ -83,30 +83,29 @@ function toLayoutId(layout) {
 	if (isNamedLayout(layout)) return layout.directory ? `${layout.directory}/_layouts/${layout.name}` : `_layouts/${layout.name}`;
 	return layout.directory ? `${layout.directory}/layout` : "layout";
 }
-/** Resolve the layout chain for a component (innermost last) */
-function resolveLayoutChain(componentId, layouts) {
+function resolveLayoutDirectories(componentId, componentPath) {
+	if (componentPath) {
+		const segments = componentPath.split("/");
+		segments.pop();
+		return segments.map((_, index) => segments.slice(0, index + 1).join("/"));
+	}
 	const parts = componentId.split("/");
+	return parts.slice(0, -1).map((_, index) => parts.slice(0, index + 1).join("/"));
+}
+/** Resolve the layout chain for a component (innermost last) */
+function resolveLayoutChain(componentId, layouts, componentPath) {
 	const chain = [];
 	const root = layouts.find((layout) => layout.directory === "");
 	if (root) chain.push(root);
-	let dir = "";
-	for (let partIndex = 0; partIndex < parts.length - 1; partIndex++) {
-		dir = dir ? `${dir}/${parts[partIndex]}` : parts[partIndex];
+	for (const dir of resolveLayoutDirectories(componentId, componentPath)) {
 		const layout = layouts.find((candidate) => candidate.directory === dir);
 		if (layout) chain.push(layout);
 	}
 	return chain;
 }
 /** Walk up directory tree to find closest _layouts/<name> */
-function resolveNamedLayout(name, componentId, namedLayouts) {
-	const parts = componentId.split("/");
-	const dirs = [];
-	let dir = "";
-	for (let partIndex = 0; partIndex < parts.length - 1; partIndex++) {
-		dir = dir ? `${dir}/${parts[partIndex]}` : parts[partIndex];
-		dirs.push(dir);
-	}
-	dirs.reverse();
+function resolveNamedLayout(name, componentId, namedLayouts, componentPath) {
+	const dirs = resolveLayoutDirectories(componentId, componentPath).reverse();
 	dirs.push("");
 	for (const directory of dirs) {
 		const found = namedLayouts.find((namedLayout) => namedLayout.name === name && namedLayout.directory === directory);
@@ -116,7 +115,7 @@ function resolveNamedLayout(name, componentId, namedLayouts) {
 }
 function resolveEffectiveLayoutEntries(page, layouts, namedLayouts) {
 	if (page.layout === false) return [];
-	const defaultChain = resolveLayoutChain(page.componentId, layouts).map((layout) => ({
+	const defaultChain = resolveLayoutChain(page.componentId, layouts, page.componentPath).map((layout) => ({
 		id: toLayoutId(layout),
 		definition: layout
 	}));
@@ -124,7 +123,7 @@ function resolveEffectiveLayoutEntries(page, layouts, namedLayouts) {
 	const isExclusive = page.layout.startsWith("!");
 	const name = isExclusive ? page.layout.slice(1) : page.layout;
 	if (name.startsWith(".") || name.startsWith("/")) return defaultChain;
-	const resolved = resolveNamedLayout(name, page.componentId, namedLayouts);
+	const resolved = resolveNamedLayout(name, page.componentId, namedLayouts, page.componentPath);
 	if (!resolved) return defaultChain;
 	const namedEntry = {
 		id: toLayoutId(resolved),
@@ -160,13 +159,31 @@ const SERVER_EXTENSIONS = [
 	"mts"
 ];
 const PAGES_EXPORT_RE = /export\s+(?:const|function|async\s+function)\s+(loader|actions?)\b/g;
-const REVALIDATE_RE = /export\s+const\s+revalidate\s*=\s*(\d+)\s*;/;
-const PRERENDER_RE = /export\s+const\s+prerender\s*=\s*true\s*;/;
-const PRERENDER_FALSE_RE = /export\s+const\s+prerender\s*=\s*false\s*;/;
+const REVALIDATE_RE = /export\s+const\s+revalidate\s*=\s*(\d+)\s*;?/;
+const PRERENDER_RE = /export\s+const\s+prerender\s*=\s*true\s*;?/;
+const PRERENDER_FALSE_RE = /export\s+const\s+prerender\s*=\s*false\s*;?/;
+const SSR_TRUE_RE = /export\s+const\s+ssr\s*=\s*true\s*;?/;
+const SSR_FALSE_RE = /export\s+const\s+ssr\s*=\s*false\s*;?/;
 const GET_PRERENDER_PATHS_RE = /export\s+(?:async\s+)?function\s+getPrerenderPaths\b/;
 const LAYOUT_STRING_RE = /export\s+const\s+layout\s*=\s*["']([^"']+)["']\s*;?/;
 const LAYOUT_FALSE_RE = /export\s+const\s+layout\s*=\s*false\s*;?/;
 const MAX_REVALIDATE = 31536e3;
+function inferAutoPrerender(page, options) {
+	const isDynamic = page.params.length > 0 || page.catchAll;
+	if (options?.output === "static") return !isDynamic || page.hasGetPrerenderPaths === true;
+	return page.island === true && !page.methods.includes("loader") && !isDynamic;
+}
+function resolvePageRendering(page, options) {
+	if (page.island && page.ssr === false) throw new Error(`pages: ssr = false is not valid for island page '${page.componentPath}'.`);
+	const ssrMode = page.ssr === true ? "server" : page.ssr === false ? "client" : "auto";
+	const prerenderMode = page.prerender === true ? "force" : page.prerender === false ? "disabled" : "auto";
+	return {
+		ssrMode,
+		prerenderMode,
+		renderMode: page.island === true ? "island" : ssrMode === "client" ? "client" : "server",
+		shouldPrerender: prerenderMode === "force" || prerenderMode === "auto" && inferAutoPrerender(page, options)
+	};
+}
 async function scanPages(root, options) {
 	const pagesDir = options?.pagesDir ?? options?.paths?.pagesDir ?? readProjectPaths(root).pagesDir;
 	if (!existsSync(pagesDir)) return {
@@ -219,7 +236,7 @@ async function scanPages(root, options) {
 		const methods = [];
 		let revalidate;
 		let prerender;
-		let prerenderExplicitlyFalse = false;
+		let ssr;
 		let hasGetPrerenderPaths;
 		const serverBase = hasIslandSuffix ? file.replace(`.island${ext}`, "") : file.replace(ext, "");
 		for (const serverExt of SERVER_EXTENSIONS) {
@@ -231,17 +248,24 @@ async function scanPages(root, options) {
 				const revalidateMatch = content.match(REVALIDATE_RE);
 				if (revalidateMatch) revalidate = Number(revalidateMatch[1]);
 				if (PRERENDER_RE.test(content)) prerender = true;
-				if (PRERENDER_FALSE_RE.test(content)) prerenderExplicitlyFalse = true;
+				else if (PRERENDER_FALSE_RE.test(content)) prerender = false;
+				if (SSR_TRUE_RE.test(content)) ssr = true;
+				else if (SSR_FALSE_RE.test(content)) ssr = false;
 				if (GET_PRERENDER_PATHS_RE.test(content)) hasGetPrerenderPaths = true;
 				break;
 			}
 		}
-		if (options?.output === "static") {
-			if (!prerenderExplicitlyFalse && prerender !== true) {
-				if (!(route.params.length > 0 || route.catchAll) || hasGetPrerenderPaths) prerender = true;
-			}
-		} else if (island && !methods.includes("loader") && route.params.length === 0 && !route.catchAll && !prerenderExplicitlyFalse) prerender = true;
-		if (prerender && revalidate === void 0) revalidate = MAX_REVALIDATE;
+		const rendering = resolvePageRendering({
+			componentPath: file,
+			island,
+			ssr,
+			prerender,
+			methods,
+			params: route.params,
+			catchAll: route.catchAll,
+			hasGetPrerenderPaths
+		}, options);
+		if (rendering.shouldPrerender && revalidate === void 0) revalidate = MAX_REVALIDATE;
 		let metadata;
 		let layout;
 		if (ext === ".md") {
@@ -264,6 +288,8 @@ async function scanPages(root, options) {
 			componentId,
 			revalidate,
 			prerender,
+			ssr,
+			...rendering,
 			hasGetPrerenderPaths,
 			island,
 			metadata,
@@ -291,7 +317,7 @@ async function scanPages(root, options) {
 		if (page.layout === void 0 || page.layout === false) continue;
 		const name = page.layout.startsWith("!") ? page.layout.slice(1) : page.layout;
 		if (name.startsWith(".") || name.startsWith("/")) continue;
-		if (!resolveNamedLayout(name, page.componentId, namedLayouts)) throw new Error(`pages: Page '${page.componentPath}' specifies layout '${page.layout}', but _layouts/${name}.vue was not found in any ancestor directory.`);
+		if (!resolveNamedLayout(name, page.componentId, namedLayouts, page.componentPath)) throw new Error(`pages: Page '${page.componentPath}' specifies layout '${page.layout}', but _layouts/${name}.vue was not found in any ancestor directory.`);
 	}
 	return {
 		pages,

package/dist/{types-Dm9kep2X.d.mts → types-DEWCqHtl.d.mts}

@@ -1,4 +1,8 @@
 //#region src/pages/types.d.ts
+type ExplicitBoolean = true | false | undefined;
+type SsrMode = "auto" | "server" | "client";
+type PrerenderMode = "auto" | "force" | "disabled";
+type PageRenderMode = "server" | "client" | "island";
 type PageDefinition = {
   /** URL pattern, e.g. "/users/:id" */pattern: string; /** Route params, e.g. ["id"] */
   params: Array<string>; /** Whether this is a catch-all route */
@@ -7,8 +11,13 @@ type PageDefinition = {
   serverPath: string | null; /** HTTP methods exported by server handler */
   methods: Array<string>; /** Component ID used in page object, e.g. "users/[id]" */
   componentId: string; /** Edge caching revalidate TTL in seconds, from .server.ts export */
-  revalidate?: number; /** Whether `export const prerender = true` is set in server handler */
-  prerender?: boolean; /** Whether `export function getPrerenderPaths` is defined in server handler */
+  revalidate?: number; /** Whether `export const prerender = true/false` is set in server handler */
+  prerender?: ExplicitBoolean; /** Whether `export const ssr = true/false` is set in server handler */
+  ssr?: ExplicitBoolean; /** Normalized SSR mode from the public `ssr` export */
+  ssrMode: SsrMode; /** Normalized prerender mode from the public `prerender` export */
+  prerenderMode: PrerenderMode; /** Normalized page render mode */
+  renderMode: PageRenderMode; /** Whether this page should participate in prerender collection */
+  shouldPrerender: boolean; /** Whether `export function getPrerenderPaths` is defined in server handler */
   hasGetPrerenderPaths?: boolean; /** Whether this is an island page (.island.tsx/.island.vue) */
   island?: boolean; /** Frontmatter metadata extracted from .md files (title, description) */
   metadata?: {
@@ -39,4 +48,4 @@ type DevCssAsset = {
   css: string;
 };
 //#endregion
-export { PageScanResult as a, PageDefinition as i, LayoutDefinition as n, NamedLayoutDefinition as r, DevCssAsset as t };
+export { PageRenderMode as a, PageDefinition as i, LayoutDefinition as n, PageScanResult as o, NamedLayoutDefinition as r, DevCssAsset as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "void",
-  "version": "0.9.1",
+  "version": "0.9.3",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/voidzero-dev/void.git",
@@ -353,7 +353,7 @@
     "valibot": ">=1.0.0-beta.7",
     "vite": "^8.0.0",
     "zod": "^3.25.0 || ^4.0.0",
-    "@void/md": "0.9.1"
+    "@void/md": "0.9.3"
   },
   "peerDependenciesMeta": {
     "@void/md": {

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

@@ -4,7 +4,7 @@ outline: deep
 
 # AI
 
-Void provides a typed AI client powered by Cloudflare's [AI Gateway](https://developers.cloudflare.com/ai-gateway/). It supports both [Workers AI](https://developers.cloudflare.com/workers-ai/) models and third-party providers such as OpenAI, Anthropic, and Google through bring-your-own-key credentials. Import `ai` from `void/ai` and run inference directly from your route handlers. Usage is metered through Void.
+Void provides a typed AI client powered by Cloudflare's [AI Gateway](https://developers.cloudflare.com/ai-gateway/). Import `ai` from `void/ai` and run inference directly from your route handlers. Usage is metered through Void.
 
 ```ts
 import { ai } from 'void/ai';
@@ -29,7 +29,7 @@ export const POST = defineHandler(async (c) => {
 });
 ```
 
-You can use any model available on [Workers AI](https://developers.cloudflare.com/workers-ai/models/), including text generation, image classification, image-to-text, text-to-image, embeddings, translation, and more. Models that return binary data, such as generated images, are returned as a `Blob` from `ai.run()`.
+You can use any model available through Cloudflare's AI binding, including Workers AI models such as `@cf/meta/llama-3.1-8b-instruct` and Cloudflare Gateway models such as `google/gemini-2.5-flash` or `openai/gpt-4.1-mini`. The input object must match the selected Cloudflare model's schema. Models that return binary data, such as generated images, are returned as a `Blob` from `ai.run()`.
 
 ## Streaming
 
@@ -87,11 +87,52 @@ Workers AI usage is metered in [**neurons**](https://developers.cloudflare.com/w
 
 On the **free tier**, AI requests return a `429` error once the limit is reached. On **paid tiers**, usage beyond the included allowance is tracked as overage on your monthly bill.
 
-## Third-Party Providers (BYOK)
+## Cloudflare Gateway Models
 
-You can use models from OpenAI, Anthropic, Google, and other providers by passing a `provider/model` identifier. Bring your own API key, add it as a project secret, and Void handles the rest. Third-party inference is billed directly by the provider, and Void does not mark up API calls. Requests still route through AI Gateway so usage shows up on the dashboard.
+`ai.run()` mirrors Cloudflare's `env.AI.run()` model naming and input schemas. Third-party models use Cloudflare model IDs and Cloudflare-managed credentials.
 
-### Usage
+```ts
+const result = await ai.run('google/gemini-2.5-flash', {
+  contents: [
+    {
+      role: 'user',
+      parts: [{ text: 'Explain Durable Objects in one paragraph.' }],
+    },
+  ],
+});
+```
+
+OpenAI-compatible models use OpenAI-style `messages`:
+
+```ts
+const result = await ai.run('openai/gpt-4.1-mini', {
+  messages: [{ role: 'user', content: 'Summarize this deploy.' }],
+});
+```
+
+Pass Cloudflare AI Gateway options as the third argument:
+
+```ts
+const result = await ai.run(
+  'openai/gpt-4.1-mini',
+  {
+    messages: [{ role: 'user', content: 'Summarize this deploy.' }],
+  },
+  {
+    gateway: {
+      skipCache: true,
+    },
+  },
+);
+```
+
+Void always injects the `void` gateway ID and project metadata for metering.
+
+## Provider-Native Requests
+
+Use `ai.provider(provider).fetch(path, init)` when you want to call a provider-native API with your own provider key. The request still routes through Cloudflare AI Gateway and Void metering, but the request shape is the provider's native HTTP API.
+
+### OpenAI
 
 ```ts
 import { defineHandler } from 'void';
@@ -100,85 +141,99 @@ import { ai } from 'void/ai';
 export const POST = defineHandler(async (c) => {
   const { prompt } = await c.req.json();
 
-  const result = await ai.run('openai/gpt-4o', {
-    messages: [{ role: 'user', content: prompt }],
-    max_tokens: 512,
+  const response = await ai.provider('openai').fetch('/chat/completions', {
+    body: {
+      model: 'gpt-4o',
+      messages: [{ role: 'user', content: prompt }],
+      max_tokens: 512,
+    },
   });
 
+  const result = await response.json();
   return c.json(result);
 });
 ```
 
-The same `ai.run()` and `ai.stream()` methods work for both Workers AI and third-party models. The framework detects the provider from the model string and routes the request through [AI Gateway](https://developers.cloudflare.com/ai-gateway/) automatically.
-
-The options follow each provider's conventions. All third-party providers use the OpenAI-compatible chat completions format, including `messages`, `max_tokens`, and `temperature`. TypeScript narrows the input and return types based on the model string: Workers AI models get per-model typed inputs from `@cloudflare/workers-types`, while third-party models such as `"provider/model"` get `ChatCompletionInputs` and `ChatCompletionResponse`.
-
-### Vision
-
-Third-party chat models that accept image inputs can receive OpenAI-compatible multimodal message content:
+### Google AI Studio
 
 ```ts
-const result = await ai.run('openai/gpt-4o', {
-  messages: [
-    {
-      role: 'user',
-      content: [
-        { type: 'text', text: 'What is in this image?' },
+const response = await ai
+  .provider('google-ai-studio')
+  .fetch('/v1/models/gemini-2.5-flash:generateContent', {
+    body: {
+      contents: [
         {
-          type: 'image_url',
-          image_url: { url: 'data:image/png;base64,...', detail: 'high' },
+          role: 'user',
+          parts: [{ text: 'What is Cloudflare?' }],
         },
       ],
     },
-  ],
-});
+  });
+
+const result = await response.json();
+```
+
+### Custom Providers
+
+For providers that are not in Void's default key map, pass the secret name and API-key header:
+
+```ts
+const response = await ai
+  .provider('custom-provider', {
+    apiKeyEnv: 'CUSTOM_PROVIDER_API_KEY',
+    apiKeyHeader: 'x-api-key',
+    apiKeyPrefix: '',
+  })
+  .fetch('/v1/respond', {
+    body: { prompt: 'Hello' },
+  });
 ```
 
 ### Image Generation
 
-Use `ai.image()` for image-generation providers or Workers AI image models. It returns a `Response`, so route handlers can return it directly or parse it as JSON depending on the provider:
+Use `ai.run()` or `ai.image()` for Cloudflare-native image models:
 
 ```ts
 export const POST = defineHandler(async (c) => {
   const { prompt } = await c.req.json();
-
-  return ai.image('openai/gpt-image-1.5', {
-    prompt,
-    size: '1024x1024',
-    response_format: 'b64_json',
-  });
+  return ai.image('@cf/black-forest-labs/flux-1-schnell', { prompt });
 });
 ```
 
-For Workers AI text-to-image models, pass the model name and input shape from Cloudflare's model docs:
+Use `ai.provider().fetch()` for provider-native image APIs:
 
 ```ts
 export const POST = defineHandler(async (c) => {
   const { prompt } = await c.req.json();
-  return ai.image('@cf/black-forest-labs/flux-1-schnell', { prompt });
+
+  return ai.provider('openai').fetch('/images/generations', {
+    body: {
+      model: 'gpt-image-1.5',
+      prompt,
+      size: '1024x1024',
+      response_format: 'b64_json',
+    },
+  });
 });
 ```
 
-For image edits, pass the file-like input and select the edit endpoint. Void serializes the file through the proxy and forwards it to AI Gateway as multipart form data:
+For multipart provider APIs, pass a `FormData` body. Void serializes the body through the proxy and reconstructs it before forwarding to AI Gateway:
 
 ```ts
 export const POST = defineHandler(async (c) => {
   const body = await c.req.parseBody();
+  const form = new FormData();
+  form.set('model', 'gpt-image-1.5');
+  form.set('prompt', String(body.prompt));
+  form.set('image', body.image as Blob, 'source.png');
 
-  return ai.image(
-    'openai/gpt-image-1.5',
-    {
-      prompt: String(body.prompt),
-      image: body.image as Blob,
-    },
-    { endpoint: 'images/edits' },
-  );
+  return ai.provider('openai').fetch('/images/edits', { body: form });
 });
 ```
 
 ### Provider Key Convention
 
-Each provider requires an API key set as a project secret. The env var name is automatically derived from the provider prefix:
+Provider-native requests require an API key set as a project secret. The env var name is automatically derived from the provider name:
 
 | Provider prefix    | Env var               |
 | ------------------ | --------------------- |
@@ -203,7 +258,7 @@ Each provider requires an API key set as a project secret. The env var name is a
 | `ideogram`         | `IDEOGRAM_API_KEY`    |
 | `parallel`         | `PARALLEL_API_KEY`    |
 
-All [AI Gateway providers](https://developers.cloudflare.com/ai-gateway/usage/providers/) that accept a Bearer API key are supported. Providers with non-standard auth (Amazon Bedrock, Azure OpenAI, Google Vertex) are not yet supported.
+OpenAI-style providers use `Authorization: Bearer <key>`. Google AI Studio uses `x-goog-api-key`. Use `apiKeyHeader` and `apiKeyPrefix` for custom providers.
 
 For production, add your API key as a project secret:
 
@@ -217,19 +272,22 @@ For local development, add it to `.env.local` in your project root:
 OPENAI_API_KEY=sk-...
 ```
 
-If the key is missing at runtime, `ai.run()` throws a descriptive error telling you which env var to set.
+If the key is missing at runtime, `ai.provider().fetch()` throws a descriptive error telling you which env var to set.
 
-### Streaming with Third-Party Models
+### Streaming with Provider-Native APIs
 
-`ai.stream()` works the same way. The response is always SSE regardless of provider:
+Provider-native streaming APIs return the provider response directly:
 
 ```ts
 export const POST = defineHandler(async (c) => {
   const { prompt } = await c.req.json();
 
-  return ai.stream('anthropic/claude-sonnet-4-20250514', {
-    messages: [{ role: 'user', content: prompt }],
-    max_tokens: 512,
+  return ai.provider('openai').fetch('/chat/completions', {
+    body: {
+      model: 'gpt-4o',
+      messages: [{ role: 'user', content: prompt }],
+      stream: true,
+    },
   });
 });
 ```

package/skills/void/docs/guide/pages-routing/layouts.md

@@ -149,7 +149,7 @@ import { useShared, Link } from '@void/solid';
 import type { JSX } from 'solid-js';
 
 export default function Layout(props: { children: JSX.Element }) {
-  const shared = useShared<{ auth: { user: { name: string } | null } }>();
+  const shared = useShared();
   return (
     <>
       <nav>
@@ -307,15 +307,16 @@ Middleware can inject data available on every page via `c.set("shared", {...})`.
 ```ts
 // middleware/01.auth.ts
 import { defineMiddleware } from 'void';
+import { getUser, type AuthUser } from 'void/auth';
 
 declare module 'void' {
   interface CloudContextVariables {
-    shared: { auth: { user: { name: string } | null } };
+    shared: { auth: { user: AuthUser | null } };
   }
 }
 
 export default defineMiddleware(async (c, next) => {
-  const user = await getSessionUser(c);
+  const user = getUser();
   c.set('shared', { auth: { user } });
   await next();
 });
@@ -329,7 +330,7 @@ Access it on the client with `useShared()`. The return type is inferred from you
 import { useShared } from '@void/react';
 
 export default function Page() {
-  const { auth } = useShared(); // { auth: { user: { name: string } | null } }
+  const { auth } = useShared(); // { auth: { user: AuthUser | null } }
   return <p>Hello, {auth?.user?.name}</p>;
 }
 ```
@@ -337,14 +338,14 @@ export default function Page() {
 ```vue [Vue]
 <script setup lang="ts">
 import { useShared } from '@void/vue';
-const { auth } = useShared(); // { auth: { user: { name: string } | null } }
+const { auth } = useShared(); // { auth: { user: AuthUser | null } }
 </script>
 ```
 
 ```svelte [Svelte]
 <script>
   import { useShared } from "@void/svelte";
-  const { auth } = useShared(); // { auth: { user: { name: string } | null } }
+  const { auth } = useShared(); // { auth: { user: AuthUser | null } }
 </script>
 ```
 
@@ -352,7 +353,7 @@ const { auth } = useShared(); // { auth: { user: { name: string } | null } }
 import { useShared } from '@void/solid';
 
 export default function Page() {
-  const shared = useShared(); // { auth: { user: { name: string } | null } }
+  const shared = useShared(); // { auth: { user: AuthUser | null } }
   return <p>Hello, {shared.auth?.user?.name}</p>;
 }
 ```

package/skills/void/docs/guide/pages-routing/loaders.md

@@ -237,7 +237,7 @@ export default function Dashboard(props: Props) {
 
 ### How Streaming Works
 
-On the initial page load (SSR), React uses React 19 streaming SSR and renders the nearest Suspense fallback for deferred props; the other adapters render their loading state. As each deferred function resolves, the server streams an inline `<script>` tag that delivers the data, so no extra HTTP request is needed. On SPA navigation, deferred data streams via NDJSON over the same response.
+On the initial page load (SSR), React uses React 19 streaming SSR and renders the nearest Suspense fallback for deferred props; the other adapters render their loading state. As each deferred function resolves, the server streams an inline `<script>` tag that delivers the data, so no extra HTTP request is needed. Routes with `export const ssr = false` skip server-rendered component HTML but still stream deferred resolution scripts after the client-mounted shell. On SPA navigation, deferred data streams via NDJSON over the same response.
 
 ### Deferred Props After Mutations
 

package/skills/void/docs/guide/pages-routing/overview.md

@@ -100,6 +100,7 @@ Each page can have a companion `.server.ts` file that runs exclusively on the se
 
 - A [**loader**](./loaders), which runs on `GET` and returns the data that becomes the page component's props
 - [**Actions**](./actions-and-forms), which handle mutations from forms and programmatic calls. Export a single `action` or multiple [named actions](./actions-and-forms#named-actions) when a page has several mutations
+- `ssr = false` to opt a route out of server-rendered component HTML while keeping server loaders and client-side routing
 
 File-based routing rules are the same as [server routing](../server-routing.md): `[param]` for dynamic segments, `[...param]` for catch-all, `(group)/` for route groups.
 
@@ -107,14 +108,40 @@ File-based routing rules are the same as [server routing](../server-routing.md):
 
 Pages uses an Inertia-style protocol under the hood:
 
-| Request               | Response                                                              |
-| --------------------- | --------------------------------------------------------------------- |
-| Initial page load     | Full SSR HTML. Client hydrates automatically.                         |
-| Subsequent navigation | JSON with component name + props. Client component swap or re-render. |
-| Form submission       | Runs action, then returns fresh props or a redirect.                  |
+| Request               | Response                                                                                                       |
+| --------------------- | -------------------------------------------------------------------------------------------------------------- |
+| Initial page load     | Full SSR HTML. Client hydrates automatically. Routes with `ssr = false` return a client-mounted shell instead. |
+| Subsequent navigation | JSON with component name + props. Client component swap or re-render.                                          |
+| Form submission       | Runs action, then returns fresh props or a redirect.                                                           |
 
 This means the first page load is server-rendered for SEO and performance, while later navigations stay fast without full page reloads.
 
+To opt a specific route out of server-rendered component HTML, export `ssr = false` from its companion `.server.ts` file:
+
+```ts
+// pages/dashboard.server.ts
+import { defineHandler } from 'void';
+
+export const ssr = false;
+
+export const loader = defineHandler(async () => {
+  return { title: 'Dashboard' };
+});
+```
+
+The loader still runs on the first request, and its props are embedded in the HTML shell. The page component mounts in the browser instead of hydrating server-rendered markup.
+
+Render and prerender flags combine like this:
+
+| Page exports                           | Behavior                                                                  |
+| -------------------------------------- | ------------------------------------------------------------------------- |
+| `ssr` unset or `true`                  | Server-render component HTML on request.                                  |
+| `ssr = false`                          | Return a client-mounted shell on request.                                 |
+| `ssr = false` + `prerender = true`     | Prerender a client-mounted shell with embedded loader data.               |
+| `ssr = false` + `prerender = false`    | Return the client-mounted shell only on request; never prerender it.      |
+| Island page + `ssr = false`            | Invalid. Island pages already use the island renderer.                    |
+| `output: "static"` + `prerender` unset | Auto-prerender pages that have known paths, including client-only shells. |
+
 Use the `Link` component for SPA navigation between pages. It renders an `<a>` tag that intercepts clicks and navigates without a full page reload:
 
 ::: code-group

package/skills/void/docs/guide/server-routing.md

@@ -191,6 +191,34 @@ export default defineMiddleware(async (c, next) => {
 
 `defineMiddleware` uses Hono middleware semantics: `(c, next) => Promise<void> | void`.
 
+For a temporary full-site gate, use the built-in `basicAuth()` middleware with credentials from `void/env`. Void internal endpoints under `/__void` are excluded automatically so deploy migrations and dev tooling continue to work. Wrap `void/env` reads in functions so they are resolved per request after Void has bound the runtime env.
+
+```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',
+});
+```
+
+Set `BASIC_AUTH_USERNAME` and `BASIC_AUTH_PASSWORD` as local environment variables for development and production secrets before deploy.
+
+For app-specific bypasses such as health checks or public webhooks, compose that logic in your own middleware before calling `basicAuth()`.
+
 Middleware can set typed context variables using `c.set()`. Augment the `CloudContextVariables` interface so downstream handlers get full type safety:
 
 ```ts