void 1.2.1 → 1.3.0

package/dist/{scan-8IzYXiU_.mjs → scan-N9WzdcAl.mjs}

@@ -1,13 +1,136 @@
-import { a as join, n as dirname, r as extname, t as basename } from "./dist-ipQi0Q8y.mjs";
+import { a as join, l as toSlash, n as dirname, r as extname, t as basename } from "./dist-ipQi0Q8y.mjs";
 import { n as readProjectPaths } from "./project-paths-DGu_QZ_Q.mjs";
 import { t as glob } from "./dist-D15hFhP0.mjs";
 import { n as isIdentifier, o as moduleExportName, r as isLiteral } from "./ast-CsZ_q_gc.mjs";
 import { a as staticLiteral, i as staticExportInitializers, t as bindingNames } from "./ast-bindings-C3yaPs1y.mjs";
-import { n as parseRouteFilename } from "./parse-filename-DioPHiR9.mjs";
 import { i as voidWarn } from "./log-BMwmN5Ae.mjs";
 import { t as MagicString } from "./dist-Cegxq8gs.mjs";
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, statSync } from "node:fs";
 import { parseSync } from "vite";
+//#region src/shared/route-extensions.ts
+const ROUTE_EXTENSIONS = [
+	"ts",
+	"tsx",
+	"js",
+	"jsx",
+	"mjs",
+	"mts"
+];
+const ROUTE_EXTENSIONS_SET = new Set(ROUTE_EXTENSIONS.map((ext) => `.${ext}`));
+//#endregion
+//#region src/router/parse-filename.ts
+const ENV_SUFFIXES = ["dev", "prod"];
+function parsePath(relativePath, isWebSocketRoute) {
+	const filePath = relativePath;
+	let path = relativePath.replace(/\\/g, "/");
+	for (const ext of ROUTE_EXTENSIONS) if (path.endsWith(`.${ext}`)) {
+		path = path.slice(0, -(ext.length + 1));
+		break;
+	}
+	if (isWebSocketRoute && path.endsWith(".ws")) path = path.slice(0, -3);
+	const segments = path.split("/");
+	let filename = segments.pop();
+	let env = null;
+	for (const suffix of ENV_SUFFIXES) if (filename.endsWith(`.${suffix}`)) {
+		env = suffix;
+		filename = filename.slice(0, -(suffix.length + 1));
+		break;
+	}
+	segments.push(filename);
+	if (segments[segments.length - 1] === "index") segments.pop();
+	const filtered = segments.filter((s) => !s.startsWith("(") || !s.endsWith(")"));
+	const params = [];
+	let catchAll = false;
+	return {
+		pattern: "/" + filtered.map((segment) => {
+			if (segment.startsWith("[...") && segment.endsWith("]")) {
+				const paramName = segment.slice(4, -1);
+				catchAll = true;
+				if (paramName) {
+					params.push(paramName);
+					return `:${paramName}{.+}`;
+				}
+				return "*";
+			}
+			if (segment.startsWith("[") && segment.endsWith("]")) {
+				const paramName = segment.slice(1, -1);
+				params.push(paramName);
+				return `:${paramName}`;
+			}
+			return segment;
+		}).join("/"),
+		methods: [],
+		params,
+		catchAll,
+		env,
+		filePath
+	};
+}
+/**
+* Parse a route filename (relative to routes/) into a RouteDefinition.
+*
+* Rules (applied in order):
+* 1. Strip file extension (.ts, .tsx, .js, .jsx, .mts, .mjs)
+* 2. Check for env suffix (.dev, .prod) → strip and record
+* 3. Strip trailing "index" segment
+* 4. Remove route group directories: (groupname)
+* 5. Convert [param] → :param, [...param] → :param{.+}, [...] → *
+* 6. Prefix with /
+*/
+function parseRouteFilename(relativePath) {
+	return parsePath(relativePath, false);
+}
+/** Parse a `.ws.*` route filename into a regular route definition. */
+function parseWebSocketFilename(relativePath) {
+	return parsePath(relativePath, true);
+}
+function isRouteEnabledForEnvironment(route, environment) {
+	return environment === void 0 || route.env === null || route.env === environment;
+}
+//#endregion
+//#region src/shared/source-analysis-cache.ts
+/**
+* How long after a file changes its stat is trusted to identify its contents.
+* Some file systems keep coarse timestamps (FAT: 2 s, HFS+: 1 s, ext4: one
+* kernel tick) and Linux reuses inodes, so a second write inside that window
+* can leave the signature unchanged. Like Git's racily clean index entries,
+* values derived from recently changed files are recomputed on the next read.
+*/
+const RACY_WINDOW_MS = 3e3;
+const entries = /* @__PURE__ */ new Map();
+/**
+* Derive a value from a source file, reusing it while the file is unchanged.
+* A dev server rescans every source file on each file event, and several
+* plugins scan the same pages, but only edited files need to be read and
+* parsed again. `kind` separates analyses of the same file. `derive` must be a
+* pure function of the source, and callers must not mutate its result.
+*/
+function deriveFromSource(path, kind, derive) {
+	const key = toSlash(path);
+	const stat = statSync(key, {
+		bigint: true,
+		throwIfNoEntry: false
+	});
+	if (!stat) return derive(readFileSync(key, "utf-8"));
+	const signature = `${stat.ino}:${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}`;
+	const changedAt = Number((stat.mtimeNs > stat.ctimeNs ? stat.mtimeNs : stat.ctimeNs) / 1000000n);
+	const trusted = Date.now() - changedAt > RACY_WINDOW_MS;
+	const entry = entries.get(key);
+	if (trusted && entry?.signature === signature && entry.derived.has(kind)) return entry.derived.get(kind);
+	const value = derive(readFileSync(key, "utf-8"));
+	if (!trusted) entries.delete(key);
+	else if (entry?.signature === signature) entry.derived.set(kind, value);
+	else entries.set(key, {
+		signature,
+		derived: /* @__PURE__ */ new Map([[kind, value]])
+	});
+	return value;
+}
+/** Forget values derived from a file. Dev servers call this for watcher events. */
+function invalidateSourceAnalysis(path) {
+	entries.delete(toSlash(path));
+}
+//#endregion
 //#region src/pages/island-imports.ts
 /** The whole JS/TS module, or each `<script>` block of a Vue/Svelte SFC with its offset in the file. */
 function scriptBlocks(code, filename) {
@@ -150,6 +273,99 @@ function resolveLayoutIds(page, layouts, namedLayouts) {
 	return resolveEffectiveLayoutEntries(page, layouts, namedLayouts).map((layout) => layout.id);
 }
 //#endregion
+//#region src/pages/manifest.ts
+/**
+* Generates the component import map and layout tree as code strings.
+* Used by both SSR renderer and client entry virtual modules.
+*
+* Client entries load this eagerly, so it grows with every page. Each page id
+* is written once, identical layout chains are shared, and static routes are
+* matched by exact lookup instead of a RegExp per page. The emitted bindings
+* (`components`, `layoutTree`, `routeMeta`, `matchRoute`) keep their shape;
+* `matchRoute` takes a decoded pathname (see `decodePagePath`).
+*/
+function generateComponentManifest(scan, pagesDir) {
+	const load = (filePath) => `() => import(${JSON.stringify(`${pagesDir}/${filePath}`)})`;
+	const pageIds = new Set(scan.pages.map((page) => page.componentId));
+	const layoutKey = (id) => {
+		if (!pageIds.has(id)) return id;
+		const slash = id.lastIndexOf("/");
+		return id.slice(0, slash + 1) + "_" + id.slice(slash + 1);
+	};
+	const chains = [];
+	const chainIndexes = /* @__PURE__ */ new Map();
+	const staticRows = [];
+	const dynamicRows = [];
+	let inStaticPrefix = true;
+	for (const page of scan.pages) {
+		const chain = JSON.stringify(resolveLayoutIds(page, scan.layouts, scan.namedLayouts).map(layoutKey));
+		let chainIndex = chain === "[]" ? -1 : chainIndexes.get(chain);
+		if (chainIndex === void 0) {
+			chainIndex = chains.push(chain) - 1;
+			chainIndexes.set(chain, chainIndex);
+		}
+		const id = JSON.stringify(page.componentId);
+		inStaticPrefix &&= isStaticPattern(page.pattern);
+		if (inStaticPrefix) {
+			const pattern = page.pattern === `/${page.componentId}` ? "" : `, ${JSON.stringify(page.pattern)}`;
+			staticRows.push(`  [${id}, ${load(page.componentPath)}, ${chainIndex}${pattern}],`);
+		} else dynamicRows.push(`  [${patternToRegex(page.pattern)}, ${id}, ${load(page.componentPath)}, ${chainIndex}],`);
+	}
+	const lines = [];
+	lines.push("const components = {};");
+	lines.push(`const __voidLayoutChains = [${chains.join(", ")}];`);
+	lines.push("const __voidStaticRoutes = [", ...staticRows, "];");
+	lines.push("const __voidDynamicRoutes = [", ...dynamicRows, "];");
+	lines.push(`const layoutTree = {};
+const __voidStaticRouteIds = new Map();
+for (const [id, load, chain, pattern = "/" + id] of __voidStaticRoutes) {
+  components[id] = load;
+  if (chain >= 0) layoutTree[id] = __voidLayoutChains[chain];
+  if (!__voidStaticRouteIds.has(pattern)) __voidStaticRouteIds.set(pattern, id);
+}
+const routes = [];
+for (const [pattern, id, load, chain] of __voidDynamicRoutes) {
+  components[id] = load;
+  if (chain >= 0) layoutTree[id] = __voidLayoutChains[chain];
+  routes.push({ pattern, id });
+}`);
+	for (const layout of [...scan.layouts, ...scan.namedLayouts]) lines.push(`components[${JSON.stringify(layoutKey(toLayoutId(layout)))}] = ${load(layout.filePath)};`);
+	lines.push("const routeMeta = {");
+	for (const page of scan.pages) if (page.island) lines.push(`  ${JSON.stringify(page.componentId)}: { island: true },`);
+	lines.push("};");
+	lines.push(`function matchRoute(path) {
+  const id = __voidStaticRouteIds.get(path);
+  if (id !== undefined) return id;
+  for (const r of routes) {
+    if (r.pattern.test(path)) return r.id;
+  }
+  return null;
+}`);
+	return lines.join("\n");
+}
+const REGEX_SYNTAX = ".*+?^${}()|[]\\";
+/** The capture group for `*`, `:name{.+}` and `:name`; other segments match as written. */
+function captureGroup(segment) {
+	if (segment === "*") return "(.*)";
+	if (segment.length < 2 || segment[0] !== ":") return;
+	const name = segment.endsWith("{.+}") ? segment.slice(1, -4) : "";
+	return name && !name.includes("{") && !name.includes("}") ? "(.+)" : "([^\\/]+)";
+}
+/** Whether `patternToRegex` matches only the pattern's own text. */
+function isStaticPattern(pattern) {
+	return pattern.split("/").every((segment) => captureGroup(segment) === void 0);
+}
+/** The RegExp literal a page pattern matches with, the same on the client and the server. */
+function patternToRegex(pattern) {
+	return `/^${pattern.split("/").map((segment) => {
+		const group = captureGroup(segment);
+		if (group) return group;
+		let literal = "";
+		for (const char of segment) literal += REGEX_SYNTAX.includes(char) ? "\\" + char : char;
+		return literal;
+	}).join("\\/")}$/`;
+}
+//#endregion
 //#region src/pages/scan.ts
 const COMPONENT_EXTENSIONS = [
 	"vue",
@@ -158,13 +374,6 @@ const COMPONENT_EXTENSIONS = [
 	"svelte",
 	"md"
 ];
-const SERVER_EXTENSIONS = [
-	"ts",
-	"tsx",
-	"js",
-	"mjs",
-	"mts"
-];
 const PAGE_METHODS = /* @__PURE__ */ new Set([
 	"loader",
 	"action",
@@ -173,6 +382,8 @@ const PAGE_METHODS = /* @__PURE__ */ new Set([
 const MAX_REVALIDATE = 31536e3;
 /** Layout paths already reported; a dev server rescans pages on every file change. */
 const warnedLayoutPaths = /* @__PURE__ */ new Set();
+/** Unreachable pages already reported, for the same reason. */
+const warnedShadowedPages = /* @__PURE__ */ new Set();
 function componentLayout(source, filename) {
 	if (!source.includes("layout")) return;
 	for (const script of scriptBlocks(source, filename)) {
@@ -255,6 +466,23 @@ function resolvePageRendering(page, options) {
 		shouldPrerender: prerenderMode === "force" || prerenderMode === "auto" && inferAutoPrerender(page, options)
 	};
 }
+/**
+* The environment a file under pages/ is limited to, read from its name the way
+* scanPages does: `home.dev.tsx`, `home.dev.island.vue` and `home.dev.server.ts`
+* give 'dev'. Files the scanner skips (`_` segments, other extensions) give null.
+*/
+function pageFileEnvironment(relativePath) {
+	const segments = toSlash(relativePath).split("/");
+	if (segments.some((segment) => segment.startsWith("_"))) return null;
+	const file = segments[segments.length - 1];
+	const ext = extname(file);
+	let base = basename(file, ext);
+	if (ROUTE_EXTENSIONS_SET.has(ext) && base.endsWith(".server")) base = base.slice(0, -7);
+	else if (COMPONENT_EXTENSIONS.includes(ext.slice(1))) {
+		if (base.endsWith(".island")) base = base.slice(0, -7);
+	} else return null;
+	return base.endsWith(".dev") ? "dev" : base.endsWith(".prod") ? "prod" : null;
+}
 async function scanPages(root, options) {
 	const pagesDir = options?.pagesDir ?? options?.paths?.pagesDir ?? readProjectPaths(root).pagesDir;
 	if (!existsSync(pagesDir)) return {
@@ -270,11 +498,12 @@ async function scanPages(root, options) {
 	const pages = [];
 	const layouts = [];
 	const namedLayouts = [];
-	for (const file of files) {
+	for (const file of files.sort()) {
 		const segments = file.split("/");
 		if (segments.some((s) => s.startsWith("_") && s !== "_layouts")) continue;
 		const ext = extname(file);
 		let base = basename(file, ext);
+		if (base.endsWith(".server") && ROUTE_EXTENSIONS_SET.has(ext)) continue;
 		let island;
 		let hasIslandSuffix = false;
 		if (base.endsWith(".island")) {
@@ -302,8 +531,8 @@ async function scanPages(root, options) {
 			});
 			continue;
 		}
-		const parseName = hasIslandSuffix ? file.replace(`.island${ext}`, ".ts") : file.replace(ext, ".ts");
-		const route = parseRouteFilename(parseName);
+		const route = parseRouteFilename(hasIslandSuffix ? file.replace(`.island${ext}`, ".ts") : file.replace(ext, ".ts"));
+		if (!isRouteEnabledForEnvironment(route, options?.environment)) continue;
 		const componentId = file.replace(ext, "").replace(/\.island$/, "").replace(/\/index$/, "").replace(/^index$/, "") || "index";
 		let serverPath = null;
 		const methods = [];
@@ -312,11 +541,11 @@ async function scanPages(root, options) {
 		let ssr;
 		let hasGetPrerenderPaths;
 		const serverBase = hasIslandSuffix ? file.replace(`.island${ext}`, "") : file.replace(ext, "");
-		for (const serverExt of SERVER_EXTENSIONS) {
+		for (const serverExt of ROUTE_EXTENSIONS) {
 			const candidate = `${serverBase}.server.${serverExt}`;
 			if (existsSync(join(pagesDir, candidate))) {
 				serverPath = candidate;
-				const metadata = detectPageServerMetadata(readFileSync(join(pagesDir, candidate), "utf-8"), candidate);
+				const metadata = deriveFromSource(join(pagesDir, candidate), "page-server", (source) => detectPageServerMetadata(source, candidate));
 				methods.push(...metadata.methods);
 				revalidate = metadata.revalidate;
 				prerender = metadata.prerender;
@@ -338,11 +567,11 @@ async function scanPages(root, options) {
 		if (rendering.shouldPrerender && revalidate === void 0) revalidate = MAX_REVALIDATE;
 		let metadata;
 		let layout;
-		if (ext === ".md") {
-			const mdContent = readFileSync(join(pagesDir, file), "utf-8");
-			metadata = extractFrontmatterMeta(mdContent);
-			layout = extractFrontmatterLayout(mdContent);
-		} else layout = componentLayout(readFileSync(join(pagesDir, file), "utf-8"), file);
+		if (ext === ".md") ({metadata, layout} = deriveFromSource(join(pagesDir, file), "page-markdown", (source) => ({
+			metadata: extractFrontmatterMeta(source),
+			layout: extractFrontmatterLayout(source)
+		})));
+		else layout = deriveFromSource(join(pagesDir, file), "page-layout", (source) => componentLayout(source, file));
 		pages.push({
 			pattern: route.pattern,
 			params: route.params,
@@ -357,8 +586,9 @@ async function scanPages(root, options) {
 			...rendering,
 			hasGetPrerenderPaths,
 			island,
-			metadata,
-			layout
+			metadata: metadata ? { ...metadata } : void 0,
+			layout,
+			...route.env ? { env: route.env } : {}
 		});
 	}
 	pages.sort((a, b) => {
@@ -367,6 +597,14 @@ async function scanPages(root, options) {
 		if (aDynamic !== b.pattern.includes(":")) return aDynamic ? 1 : -1;
 		return a.pattern.localeCompare(b.pattern);
 	});
+	if (options?.checkRoutes !== false) {
+		const environments = options?.environment ? [options.environment] : ["dev", "prod"];
+		for (const environment of environments) {
+			const live = pages.filter((page) => isRouteEnabledForEnvironment({ env: page.env ?? null }, environment));
+			assertOnePagePerRoute(live);
+			warnShadowedPages(pagesDir, live);
+		}
+	}
 	for (const page of pages) {
 		if (page.island) continue;
 		const dir = dirname(page.componentPath);
@@ -393,6 +631,47 @@ async function scanPages(root, options) {
 		namedLayouts
 	};
 }
+function compareText(left, right) {
+	return left < right ? -1 : left > right ? 1 : 0;
+}
+/** Group sorted pages by `key`, keeping only groups with more than one page. */
+function pagesSharing(pages, key) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const page of pages) {
+		const group = groups.get(key(page));
+		if (group) group.push(page);
+		else groups.set(key(page), [page]);
+	}
+	return [...groups.values()].filter((group) => group.length > 1);
+}
+/**
+* Two files for one path have no stable winner: the server and the client can
+* each pick a different one, and the order can change between runs.
+*/
+function assertOnePagePerRoute(pages) {
+	assertNoneShare(pages, (page) => page.pattern, "pages: Multiple page files resolve to the same route:", "Keep one page file per route and rename or remove the others.");
+	assertNoneShare(pages, (page) => page.componentId, "pages: Multiple page files resolve to the same page id:", "Rename or remove one of them.");
+}
+function assertNoneShare(pages, key, title, hint) {
+	const clashes = pagesSharing(pages, key).map((group) => ({
+		key: key(group[0]),
+		files: group.map((page) => page.componentPath).sort(compareText)
+	})).sort((left, right) => compareText(left.key, right.key)).map((clash) => `  ${JSON.stringify(clash.key)}: ${clash.files.map((file) => JSON.stringify(file)).join(", ")}`);
+	if (clashes.length > 0) throw new Error([
+		title,
+		...clashes,
+		hint
+	].join("\n"));
+}
+/** Dynamic routes that match the same URLs, such as [id] and [slug]: only the first is ever used. */
+function warnShadowedPages(pagesDir, pages) {
+	for (const [used, ...shadowed] of pagesSharing(pages, (page) => patternToRegex(page.pattern))) for (const page of shadowed) {
+		const key = `${pagesDir}\0${used.componentPath}\0${page.componentPath}`;
+		if (warnedShadowedPages.has(key)) continue;
+		warnedShadowedPages.add(key);
+		voidWarn(`pages: Page '${page.componentPath}' (${page.pattern}) is never used: '${used.componentPath}' (${used.pattern}) matches the same URLs first. Remove one of them.`);
+	}
+}
 const LEADING_SCRIPT_RE = /^<script\b[^>]*>[\s\S]*?<\/script>\s*\n?/;
 /** Return the raw YAML frontmatter of markdown source, after any leading <script> block. */
 function markdownFrontmatter(source) {
@@ -424,4 +703,4 @@ function extractFrontmatterLayout(source) {
 	return value;
 }
 //#endregion
-export { resolveNamedLayout as a, findIslandImports as c, resolveLayoutIds as i, findStaticCssImports as l, resolveEffectiveLayoutChain as n, toLayoutId as o, resolveLayoutChain as r, editIslandSource as s, scanPages as t };
+export { resolveLayoutChain as a, editIslandSource as c, deriveFromSource as d, invalidateSourceAnalysis as f, ROUTE_EXTENSIONS as g, parseWebSocketFilename as h, resolveEffectiveLayoutChain as i, findIslandImports as l, parseRouteFilename as m, scanPages as n, resolveLayoutIds as o, isRouteEnabledForEnvironment as p, generateComponentManifest as r, resolveNamedLayout as s, pageFileEnvironment as t, findStaticCssImports as u };

package/dist/{secret-BbXHfLAt.mjs → secret-BL6g7mF5.mjs}

@@ -1,10 +1,10 @@
 import { n as readDeploymentPlatform, r as readProjectConfig } from "./project-rqDnVsJN.mjs";
 import { c as getToken } from "./auth-B6iOCjKI.mjs";
 import { A as confirm, H as outro, L as log, O as cancel, U as password, tt as isCancel } from "./dist-Cor9XGoz.mjs";
-import { r as PlatformClient } from "./client-BEkdj1kx.mjs";
+import { r as PlatformClient } from "./client-BEMtySaV.mjs";
 import { m as printSuccess, o as formatCount, p as note } from "./output-BpgYODYx.mjs";
 import { a as resolveProjectBySlug, t as getRequestedProjectSlug } from "./resolve-project-Xoi6eTWY.mjs";
-import { _ as validateSecretValues } from "./env-validation-Dwq3PJzK.mjs";
+import { _ as validateSecretValues } from "./env-validation-XcukUlFM.mjs";
 import { readFileSync } from "node:fs";
 //#region src/cli/secret.ts
 async function runSecretCommand(root, args) {
@@ -93,7 +93,7 @@ async function resolveSecretBackend(root, args) {
 }
 async function resolveCloudflareSecretBackend(root, args) {
 	if (args.projectName) throw new Error("secret: --project selects a Void platform project and is not used for direct Cloudflare apps.");
-	const { deleteCloudflareSecret, listCloudflareSecrets, putCloudflareSecret, resolveCloudflareOperationContext, syncCloudflareSecrets } = await import("./cloudflare-operations-DsSaw2BT.mjs");
+	const { deleteCloudflareSecret, listCloudflareSecrets, putCloudflareSecret, resolveCloudflareOperationContext, syncCloudflareSecrets } = await import("./cloudflare-operations-PCM4wucv.mjs");
 	const context = resolveCloudflareOperationContext(root);
 	return {
 		target: "Cloudflare Worker",

package/dist/static-asset-marker-Btf-6oCD.mjs

@@ -0,0 +1,32 @@
+//#region src/runtime/static-asset-marker.ts
+const STATIC_ASSET_KEY = "__voidStaticAsset";
+/**
+* Records that the fallback answered with a file from the ASSETS binding: the
+* Cache-Control it carried and its body stream. The value lives on the
+* context, not on the response object: `c.header()` after the handler rebuilds
+* `c.res`, so a response identity check would miss the file. The rebuild keeps
+* the body stream, while a middleware that swaps the body does not.
+*/
+function markStaticAsset(c, response) {
+	const mark = {
+		policy: response.headers.get("cache-control") ?? "",
+		body: response.body
+	};
+	c.set(STATIC_ASSET_KEY, mark);
+	return response;
+}
+/**
+* True when the final response is still the marked file: a success status, the
+* same body and Cache-Control the fallback served, and no cookie added by
+* later middleware.
+*/
+function isUnchangedStaticAsset(c) {
+	const mark = c.get(STATIC_ASSET_KEY);
+	return mark !== void 0 && [
+		200,
+		206,
+		304
+	].includes(c.res.status) && c.res.body === mark.body && (c.res.headers.get("cache-control") ?? "") === mark.policy && !c.res.headers.has("set-cookie");
+}
+//#endregion
+export { markStaticAsset as n, isUnchangedStaticAsset as t };

package/dist/{types-7AIz0OZu.d.mts → types-w72dljaA.d.mts}

@@ -1,3 +1,6 @@
+//#region src/router/parse-filename.d.ts
+type RouteEnvironment = "dev" | "prod";
+//#endregion
 //#region src/pages/types.d.ts
 type ExplicitBoolean = true | false | undefined;
 type SsrMode = "auto" | "server" | "client";
@@ -43,6 +46,8 @@ type PageDefinition = {
   };
   /** Named layout selection: "name", "!name", or false */
   layout?: string | false;
+  /** Environment from a `.dev` / `.prod` file suffix. Unset means both. */
+  env?: RouteEnvironment;
 };
 type LayoutDefinition = {
   /** Directory path relative to pages/, e.g. "" (root) or "users" */
@@ -76,4 +81,4 @@ type DevCssAsset = {
   css: string;
 };
 //#endregion
-export { PageRenderMode as a, PageDefinition as i, LayoutDefinition as n, PageScanResult as o, NamedLayoutDefinition as r, DevCssAsset as t };
+export { PageRenderMode as a, PageDefinition as i, LayoutDefinition as n, PageScanResult as o, NamedLayoutDefinition as r, RouteEnvironment as s, DevCssAsset as t };

package/dist/{version-metadata-tS39iW09.mjs → version-metadata-DmaZNTYW.mjs}

@@ -1,5 +1,5 @@
 import { a as join } from "./dist-ipQi0Q8y.mjs";
-import { l as bindingNamesForField, p as findBindingNameOwner } from "./wrangler-F96NnLyb.mjs";
+import { l as bindingNamesForField, p as findBindingNameOwner } from "./wrangler-CDiEBCdS.mjs";
 //#region src/shared/untrusted-env.ts
 /** Authentication inputs that Wrangler may consume from the environment. */
 const WRANGLER_AUTH_CREDENTIAL_ENV_VARS = [

package/dist/worker-conditions-AWFRcFxR.mjs

@@ -0,0 +1,11 @@
+//#region src/cli/worker-conditions.ts
+const WORKER_CONDITIONS = [
+	"workerd",
+	"worker",
+	"browser",
+	"module",
+	"import",
+	"default"
+];
+//#endregion
+export { WORKER_CONDITIONS as t };

package/dist/{wrangler-F96NnLyb.mjs → wrangler-CDiEBCdS.mjs}

@@ -666,9 +666,10 @@ function writeProvisionedWranglerConfig(root, patch, options) {
 				const matches = [];
 				for (let i = 0; i < currentList.length; i++) if (currentList[i].binding === entry.binding) matches.push(i);
 				if (matches.length > 1) throw new Error(`deploy: cannot update "${configPath}" — queue producer binding ${JSON.stringify(entry.binding)} is declared ${matches.length} times across producers. A producer binding must map to exactly one queue, so wrangler rejects this config. Remove the duplicate producers and retry.`);
+				const voidOwned = reconcileManagedQueues && managedProducerBindings.has(String(entry.binding));
 				if (matches.length === 1) {
 					const existing = currentList[matches[0]];
-					if (existing.queue !== entry.queue) throw new Error(`deploy: cannot update "${configPath}" — queue producer binding ${JSON.stringify(entry.binding)} is already bound to queue ${JSON.stringify(existing.queue)}, but queue ${JSON.stringify(entry.queue)} also requests it. A producer binding must map to exactly one queue. Rename or remove the conflicting producer and retry.`);
+					if (existing.queue !== entry.queue && !voidOwned) throw new Error(`deploy: cannot update "${configPath}" — queue producer binding ${JSON.stringify(entry.binding)} is already bound to queue ${JSON.stringify(existing.queue)}, but queue ${JSON.stringify(entry.queue)} also requests it. A producer binding must map to exactly one queue. Rename or remove the conflicting producer and retry.`);
 				}
 				index = matches.length === 1 ? matches[0] : -1;
 				workerBindingOwners ??= collectWorkerBindingNames(parseJsonc(text));

package/dist/wrangler-DOPr4jyI.mjs

@@ -0,0 +1 @@
+export { b as readRootWranglerConfig } from "./wrangler-CDiEBCdS.mjs";

package/dist/{wrapper-D3sZyh2C.mjs → wrapper-CEiDeCqD.mjs}

@@ -3,7 +3,8 @@ import { n as readProjectPaths } from "./project-paths-DGu_QZ_Q.mjs";
 import { l as getDatabaseDialect, p as readConfig } from "./config-DHgSEWT7.mjs";
 import { n as isIdentifier, r as isLiteral } from "./ast-CsZ_q_gc.mjs";
 import { t as MagicString } from "./dist-Cegxq8gs.mjs";
-import { r as voidDbBundlerPlugin, t as generateQueueResolverSource } from "./dispatch-DoUnxTNo.mjs";
+import { c as voidDbBundlerPlugin, r as cloudflareQueueName, t as generateQueueResolverSource } from "./dispatch-OVLeWW8K.mjs";
+import { t as WORKER_CONDITIONS } from "./worker-conditions-AWFRcFxR.mjs";
 import { createRequire } from "node:module";
 import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
@@ -237,14 +238,6 @@ async function bundleMigrationHandler(root, workerDir, handlerPath, dialect) {
 	if (isPostgresql || isMysql) patchWorkerRequireBundle(outDir, isPostgresql ? "PostgreSQL" : "MySQL", "migration bundle");
 	for (const file of readdirSync(outDir)) copyFileSync(join(outDir, file), join(workerDir, file));
 }
-const WORKER_CONDITIONS = [
-	"workerd",
-	"worker",
-	"browser",
-	"module",
-	"import",
-	"default"
-];
 const SQL_WORKER_EXTERNAL = [
 	/^cloudflare:/,
 	/^node:/,
@@ -414,6 +407,7 @@ async function bundleEntry(root, entry) {
 	await build({
 		root: tmpDir,
 		logLevel: "silent",
+		resolve: { conditions: [...WORKER_CONDITIONS, "production"] },
 		build: {
 			outDir,
 			emptyOutDir: true,
@@ -608,7 +602,9 @@ function generateHandlersSource(root, features, dialect) {
 			lines.push(`import queueHandler${i} from "${absPath}";`);
 		}
 		lines.push("");
-		lines.push(generateQueueResolverSource(features.queues.map((queue) => queue.name)));
+		const queueNames = features.queues.map((queue) => queue.name);
+		const cloudflareNames = features.cloudflareQueueNames;
+		lines.push(generateQueueResolverSource(queueNames, cloudflareNames && queueNames.map((name) => cloudflareQueueName(name, cloudflareNames))));
 		lines.push("");
 		lines.push(scoped ? "async function __runQueue(batch, env, ctx) {" : "export async function handleQueue(batch, env, ctx) {");
 		lines.push("  const queueSuffix = batch.queue;");

package/dist/{ws-BH-im_tX.d.mts → ws-D1zWiB_P.d.mts}

@@ -1,6 +1,6 @@
 import { t as StandardSchemaV1 } from "./standard-schema-Fo_vCAZh.mjs";
 import { r as AuthUser } from "./auth-DkcFflXV.mjs";
-import { a as CloudEnv } from "./handler-BbkSPzGF.mjs";
+import { a as CloudEnv } from "./handler-CQv5YDS0.mjs";
 import { WebSocketRouteMap } from "void/routes";
 //#region src/runtime/ws.d.ts
 type MaybePromise<T> = T | Promise<T>;

package/docs/guide/auth.md

@@ -129,6 +129,8 @@ Local development needs no secret setup. To preview a production build locally,
 
 Responses to signed-in requests get `Cache-Control: no-store`, so neither the browser cache nor a shared cache keeps a user's data. A route keeps its own policy when it sets `no-store`, or `private` together with `no-cache`. To answer repeat requests with `304`, use `private, no-cache` with Hono's [`etag()`](https://hono.dev/docs/middleware/builtin/etag) middleware. If you set the `ETag` yourself, make it differ per user, so the `304` doesn't reuse another account's page. The browser cache keeps a copy of a `private, no-cache` page, so the Back button can show it again after the user signs out. Keep the default `no-store` for pages that must not stay in the browser cache.
 
+Static files from your build and `public/` keep their own cache policy for signed-in requests, so the browser reuses cached JavaScript and CSS. When your app handles the request, the policy is marked `private`, and a request that refreshes the session cookie gets `no-store`.
+
 `POST`, `PUT`, `PATCH` and `DELETE` requests and WebSocket connections from another origin don't use the signed-in session unless that origin is in `trustedOrigins`. If a separate frontend calls your app, add its origin there (see [Customization](#customization)). If your routes use their own cookies, check the request `Origin` yourself, for example with Hono's [`csrf()`](https://hono.dev/docs/middleware/builtin/csrf) middleware.
 
 Deployed apps on Cloudflare limit auth requests per client IP with Better Auth's defaults, for example 3 sign-in attempts per 10 seconds. Each Worker instance keeps its own count. Change or turn off the limits with `rateLimit` in `auth.ts`. To share one count across instances, set `rateLimit: { storage: 'database' }`, then run `void db generate` for a direct Cloudflare deploy.
@@ -184,7 +186,7 @@ For the full set of available options, see the official [Better Auth options ref
 
 ## Database and Migrations
 
-Auth tables live alongside your app's tables. During local development, Void creates them automatically.
+Auth tables live alongside your app's tables. During local development, Void creates them automatically. While the dev server runs, saving `auth.ts`, or a local file it imports, updates the auth schema Void generates for your app. New auth tables and columns are created in the local database the next time the dev server starts.
 
 Void platforms create auth tables automatically. For a direct Cloudflare deploy, include them in your checked-in migrations:
 

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

@@ -37,6 +37,16 @@ With `void deploy --platform cloudflare`, generated JavaScript bundles with cont
 
 Use [Custom Headers](./headers) to choose a cache policy for other files. Apply immutable caching only to URLs that change whenever their content changes.
 
+Cloudflare serves these fingerprinted JavaScript bundles without starting your Worker, so they do not count as Worker requests, when your app:
+
+- has no global middleware
+- has no header, redirect, rewrite or fallback rules, and no `routing.notFound` setting
+- uses the default `base` of `/`
+- has no route or page that matches paths in the assets directory (`assets/` by default)
+- builds at most 99 fingerprinted bundles
+
+Otherwise these bundles go through your Worker and keep the same caching.
+
 ## Non-hashed assets
 
 Other static files, such as `index.html` and `favicon.ico`, are cached until the next deploy. You do not need to purge them manually.

package/docs/guide/email/domains.md

@@ -16,7 +16,7 @@ void email domain add acme.com
 
 `add` opens a Cloudflare API-token template. Restrict the token to the selected account and mail zone before creating it; Workers Scripts permission applies across that account. The CLI accepts a masked paste or a newly copied token and asks you to confirm those restrictions. The platform encrypts the credential for the zone connection, so projects sharing that zone do not need separate ingress Workers.
 
-Platform-managed custom inbound email requires the apex of a Cloudflare zone. Cloudflare’s catch-all only covers that apex, so a subdomain of the selected zone cannot receive arbitrary addresses. `add` refuses to register a new apex that already has MX records, or whose catch-all already routes elsewhere, so it never takes over mail hosted with another provider such as Microsoft 365 or Google Workspace. Use an apex that has no mail yet, or the platform’s shared mail address. Running `add` again for a registered apex, for example to renew its token, keeps working. Each custom apex belongs to one project; a project can register more than one apex.
+Platform-managed custom inbound email requires the apex of a Cloudflare zone. Cloudflare’s catch-all only covers that apex, so a subdomain of the selected zone cannot receive arbitrary addresses. `add` refuses to register a new apex that already has MX records, or whose catch-all already routes elsewhere, so it never takes over mail hosted with another provider such as Microsoft 365 or Google Workspace. Use an apex that has no mail yet, or the platform’s shared mail address. To only send from an apex that keeps its current mail provider, ask your platform administrator to register it as [outbound-only](../platform/administration/email.md#sending-from-a-domain-that-already-receives-mail). Running `add` again for a registered apex, for example to renew its token, keeps working. Each custom apex belongs to one project; a project can register more than one apex.
 
 If setup is interrupted, use `void email domain status <domain>` to inspect the saved operation before retrying.
 

package/docs/guide/email/receiving.md

@@ -94,6 +94,8 @@ deployed `email/` handlers without per-project DNS setup once the platform has v
 handlers once its inbound readiness is `ready`. Use `void email domain status`
 to check current provider routing and any remaining setup steps.
 
+A project with an [email alias](../../reference/cli/email.md#void-email-alias) also receives at `<alias>+anything@<mail domain>`. Routing ignores which prefix was used: with the slug `acme-store` and the alias `acme`, both `acme-store+support@…` and `acme+support@…` reach `email/support.ts`.
+
 For direct deployments, follow [Your own Cloudflare account](./domains.md#your-own-cloudflare-account) to configure inbound addresses.
 
 The local dev server provides the outbound email inbox but has no inbound email trigger. Test inbound handlers with `createInboundTestHarness` below.