void 0.7.5 → 0.7.7

package/dist/plugin-inference-CXUuq0aC.mjs

@@ -0,0 +1,577 @@
+import { a as join } from "./pathe.M-eThtNZ-D-kmWkCS.mjs";
+import { n as globSync } from "./dist-DUyXJLkq.mjs";
+import { existsSync, readFileSync } from "node:fs";
+import { parseSync } from "vite";
+import { parse } from "es-module-lexer/js";
+//#region ../../node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/src/walker.js
+/**
+* @typedef { import('estree').Node} Node
+* @typedef {{
+*   skip: () => void;
+*   remove: () => void;
+*   replace: (node: Node) => void;
+* }} WalkerContext
+*/
+var WalkerBase = class {
+	constructor() {
+		/** @type {boolean} */
+		this.should_skip = false;
+		/** @type {boolean} */
+		this.should_remove = false;
+		/** @type {Node | null} */
+		this.replacement = null;
+		/** @type {WalkerContext} */
+		this.context = {
+			skip: () => this.should_skip = true,
+			remove: () => this.should_remove = true,
+			replace: (node) => this.replacement = node
+		};
+	}
+	/**
+	* @template {Node} Parent
+	* @param {Parent | null | undefined} parent
+	* @param {keyof Parent | null | undefined} prop
+	* @param {number | null | undefined} index
+	* @param {Node} node
+	*/
+	replace(parent, prop, index, node) {
+		if (parent && prop) if (index != null)
+ /** @type {Array<Node>} */ parent[prop][index] = node;
+		else
+ /** @type {Node} */ parent[prop] = node;
+	}
+	/**
+	* @template {Node} Parent
+	* @param {Parent | null | undefined} parent
+	* @param {keyof Parent | null | undefined} prop
+	* @param {number | null | undefined} index
+	*/
+	remove(parent, prop, index) {
+		if (parent && prop) if (index !== null && index !== void 0)
+ /** @type {Array<Node>} */ parent[prop].splice(index, 1);
+		else delete parent[prop];
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/src/sync.js
+/**
+* @typedef { import('estree').Node} Node
+* @typedef { import('./walker.js').WalkerContext} WalkerContext
+* @typedef {(
+*    this: WalkerContext,
+*    node: Node,
+*    parent: Node | null,
+*    key: string | number | symbol | null | undefined,
+*    index: number | null | undefined
+* ) => void} SyncHandler
+*/
+var SyncWalker = class extends WalkerBase {
+	/**
+	*
+	* @param {SyncHandler} [enter]
+	* @param {SyncHandler} [leave]
+	*/
+	constructor(enter, leave) {
+		super();
+		/** @type {boolean} */
+		this.should_skip = false;
+		/** @type {boolean} */
+		this.should_remove = false;
+		/** @type {Node | null} */
+		this.replacement = null;
+		/** @type {WalkerContext} */
+		this.context = {
+			skip: () => this.should_skip = true,
+			remove: () => this.should_remove = true,
+			replace: (node) => this.replacement = node
+		};
+		/** @type {SyncHandler | undefined} */
+		this.enter = enter;
+		/** @type {SyncHandler | undefined} */
+		this.leave = leave;
+	}
+	/**
+	* @template {Node} Parent
+	* @param {Node} node
+	* @param {Parent | null} parent
+	* @param {keyof Parent} [prop]
+	* @param {number | null} [index]
+	* @returns {Node | null}
+	*/
+	visit(node, parent, prop, index) {
+		if (node) {
+			if (this.enter) {
+				const _should_skip = this.should_skip;
+				const _should_remove = this.should_remove;
+				const _replacement = this.replacement;
+				this.should_skip = false;
+				this.should_remove = false;
+				this.replacement = null;
+				this.enter.call(this.context, node, parent, prop, index);
+				if (this.replacement) {
+					node = this.replacement;
+					this.replace(parent, prop, index, node);
+				}
+				if (this.should_remove) this.remove(parent, prop, index);
+				const skipped = this.should_skip;
+				const removed = this.should_remove;
+				this.should_skip = _should_skip;
+				this.should_remove = _should_remove;
+				this.replacement = _replacement;
+				if (skipped) return node;
+				if (removed) return null;
+			}
+			/** @type {keyof Node} */
+			let key;
+			for (key in node) {
+				/** @type {unknown} */
+				const value = node[key];
+				if (value && typeof value === "object") {
+					if (Array.isArray(value)) {
+						const nodes = value;
+						for (let i = 0; i < nodes.length; i += 1) {
+							const item = nodes[i];
+							if (isNode(item)) {
+								if (!this.visit(item, node, key, i)) i--;
+							}
+						}
+					} else if (isNode(value)) this.visit(value, node, key, null);
+				}
+			}
+			if (this.leave) {
+				const _replacement = this.replacement;
+				const _should_remove = this.should_remove;
+				this.replacement = null;
+				this.should_remove = false;
+				this.leave.call(this.context, node, parent, prop, index);
+				if (this.replacement) {
+					node = this.replacement;
+					this.replace(parent, prop, index, node);
+				}
+				if (this.should_remove) this.remove(parent, prop, index);
+				const removed = this.should_remove;
+				this.replacement = _replacement;
+				this.should_remove = _should_remove;
+				if (removed) return null;
+			}
+		}
+		return node;
+	}
+};
+/**
+* Ducktype a node.
+*
+* @param {unknown} value
+* @returns {value is Node}
+*/
+function isNode(value) {
+	return value !== null && typeof value === "object" && "type" in value && typeof value.type === "string";
+}
+//#endregion
+//#region ../../node_modules/.pnpm/estree-walker@3.0.3/node_modules/estree-walker/src/index.js
+/**
+* @typedef {import('estree').Node} Node
+* @typedef {import('./sync.js').SyncHandler} SyncHandler
+* @typedef {import('./async.js').AsyncHandler} AsyncHandler
+*/
+/**
+* @param {Node} ast
+* @param {{
+*   enter?: SyncHandler
+*   leave?: SyncHandler
+* }} walker
+* @returns {Node | null}
+*/
+function walk(ast, { enter, leave }) {
+	return new SyncWalker(enter, leave).visit(ast, null);
+}
+//#endregion
+//#region src/shared/ast.ts
+function isIdentifier(node) {
+	return node?.type === "Identifier" && typeof node.name === "string";
+}
+function isLiteral(node) {
+	return node?.type === "Literal";
+}
+function isMemberExpression(node) {
+	return node?.type === "MemberExpression";
+}
+function isCallExpression(node) {
+	return node?.type === "CallExpression";
+}
+function isObjectExpression(node) {
+	return node?.type === "ObjectExpression";
+}
+//#endregion
+//#region src/inference/walk.ts
+const ENV_BINDING_RE = /\benv\s*\.\s*(DB|KV|STORAGE|QUEUE_\w+|AI|SANDBOX)\b/;
+/**
+* Infer which Cloudflare bindings a source file uses.
+*
+* Uses a tiered approach for performance:
+*   Tier 1: es-module-lexer to extract import sources (fast, asm.js, no init)
+*   Tier 2: Regex check for env.DB/KV/STORAGE patterns
+*   Tier 3: Full AST walk only when regex matches (to confirm member expressions)
+*/
+function inferBindingsFromSource(code, filename) {
+	const result = {
+		needsD1: false,
+		needsKV: false,
+		needsR2: false,
+		needsAuth: false,
+		needsQueues: false,
+		needsAI: false,
+		needsSandbox: false,
+		needsLive: false
+	};
+	try {
+		const [imports] = parse(code);
+		for (const imp of imports) {
+			const source = imp.n;
+			if (!source) continue;
+			switch (source) {
+				case "void/db":
+					result.needsD1 = true;
+					break;
+				case "void/kv":
+					result.needsKV = true;
+					break;
+				case "void/storage":
+					result.needsR2 = true;
+					break;
+				case "void/auth":
+					result.needsAuth = true;
+					break;
+				case "void/queue":
+					result.needsQueues = true;
+					break;
+				case "void/ai":
+					result.needsAI = true;
+					break;
+				case "void/sandbox":
+					result.needsSandbox = true;
+					break;
+				case "void/live":
+					if (!isTypeOnlyImportStatement(code.slice(imp.ss, imp.se + 1))) result.needsLive = true;
+					break;
+				case "void/client": {
+					const stmt = code.slice(imp.ss, imp.se + 1);
+					if (/\bauth\b/.test(stmt)) result.needsAuth = true;
+					break;
+				}
+			}
+		}
+	} catch {
+		if (/\bfrom\s+["']void\/db["']/.test(code)) result.needsD1 = true;
+		if (/\bfrom\s+["']void\/kv["']/.test(code)) result.needsKV = true;
+		if (/\bfrom\s+["']void\/storage["']/.test(code)) result.needsR2 = true;
+		if (/\bfrom\s+["']void\/auth["']/.test(code)) result.needsAuth = true;
+		if (/\bfrom\s+["']void\/queue["']/.test(code)) result.needsQueues = true;
+		if (/\bfrom\s+["']void\/ai["']/.test(code)) result.needsAI = true;
+		if (/\bfrom\s+["']void\/sandbox["']/.test(code)) result.needsSandbox = true;
+		if (hasRuntimeImportFrom(code, "void/live")) result.needsLive = true;
+		if (/\bfrom\s+["']void\/client["']/.test(code) && /\bauth\b/.test(code)) result.needsAuth = true;
+	}
+	if (result.needsD1 && result.needsKV && result.needsR2 && result.needsAI && result.needsSandbox && result.needsLive) return result;
+	if (!ENV_BINDING_RE.test(code)) return result;
+	let parsed;
+	try {
+		parsed = parseSync(filename, code);
+	} catch {
+		return result;
+	}
+	const program = parsed.program;
+	walk(program, { enter(node) {
+		const current = node;
+		if (!isMemberExpression(current)) return;
+		if (current.computed) return;
+		const property = current.property;
+		if (!isIdentifier(property)) return;
+		const obj = current.object;
+		const isViaContextEnv = isMemberExpression(obj) && isIdentifier(obj.property) && obj.property.name === "env";
+		const isDirectEnv = isIdentifier(obj) && obj.name === "env";
+		if (!isViaContextEnv && !isDirectEnv) return;
+		switch (property.name) {
+			case "DB":
+				result.needsD1 = true;
+				break;
+			case "KV":
+				result.needsKV = true;
+				break;
+			case "STORAGE":
+				result.needsR2 = true;
+				break;
+			case "AI":
+				result.needsAI = true;
+				break;
+			case "SANDBOX":
+				result.needsSandbox = true;
+				break;
+			default:
+				if (property.name.startsWith("QUEUE_")) result.needsQueues = true;
+				break;
+		}
+	} });
+	return result;
+}
+function isTypeOnlyImportStatement(statement) {
+	if (/^\s*import\s+type\b/.test(statement)) return true;
+	const specifierStart = statement.indexOf("{");
+	const specifierEnd = statement.lastIndexOf("}");
+	if (specifierStart === -1 || specifierEnd === -1 || specifierEnd < specifierStart) return false;
+	const beforeSpecifiers = statement.slice(0, specifierStart);
+	if (!/^\s*import\s*$/.test(beforeSpecifiers)) return false;
+	const specifiers = statement.slice(specifierStart + 1, specifierEnd).split(",").map((specifier) => specifier.trim()).filter(Boolean);
+	return specifiers.length > 0 && specifiers.every((specifier) => specifier.startsWith("type "));
+}
+function hasRuntimeImportFrom(code, source) {
+	const escapedSource = source.replaceAll("/", "\\/");
+	const importRe = new RegExp(`\\bimport\\s+(?:[\\s\\S]*?\\bfrom\\s+)?["']${escapedSource}["']\\s*;?`, "g");
+	for (const match of code.matchAll(importRe)) {
+		const statement = match[0];
+		if (!isTypeOnlyImportStatement(statement)) return true;
+	}
+	return false;
+}
+/**
+* Merge multiple InferredBindings into a single result (union).
+*/
+function mergeBindings(bindings) {
+	return {
+		needsD1: bindings.some((b) => b.needsD1),
+		needsKV: bindings.some((b) => b.needsKV),
+		needsR2: bindings.some((b) => b.needsR2),
+		needsAuth: bindings.some((b) => b.needsAuth),
+		needsQueues: bindings.some((b) => b.needsQueues),
+		needsAI: bindings.some((b) => b.needsAI),
+		needsSandbox: bindings.some((b) => b.needsSandbox),
+		needsLive: bindings.some((b) => b.needsLive)
+	};
+}
+//#endregion
+//#region src/ssr/entry.ts
+const SSR_SERVER_ENTRY_RELATIVE_PATHS = ["src/main.ssr.ts", "src/main.ssr.tsx"];
+const SSR_CLIENT_ENTRY_RELATIVE_PATHS = ["src/main.client.ts", "src/main.client.tsx"];
+function resolveSingleEntry(root, entries, label) {
+	const matches = entries.map((relativePath) => ({
+		relativePath,
+		absolutePath: join(root, relativePath)
+	})).filter((entry) => existsSync(entry.absolutePath));
+	if (matches.length === 0) return null;
+	if (matches.length > 1) {
+		const names = matches.map((entry) => entry.relativePath).join(", ");
+		throw new Error(`ssr: Multiple ${label} entry files found: ${names}. Keep only one.`);
+	}
+	return matches[0];
+}
+function getSsrServerEntryPath(root) {
+	return resolveSingleEntry(root, SSR_SERVER_ENTRY_RELATIVE_PATHS, "SSR")?.absolutePath ?? null;
+}
+function hasSsrEntry(root) {
+	return getSsrServerEntryPath(root) !== null;
+}
+function validateServerRenderExport(entry) {
+	const { absolutePath, relativePath } = entry;
+	const source = readFileSync(absolutePath, "utf-8");
+	if (/\bexport\s+(?:async\s+)?function\s+render\b/.test(source) || /\bexport\s+const\s+render\b/.test(source) || /\bexport\s+default\s+(?:defineRender\b|(?:async\s+)?function\b)/.test(source)) return;
+	let parsed;
+	try {
+		parsed = parseSync(relativePath, source);
+	} catch (err) {
+		throw new Error(`ssr: Invalid entry '${relativePath}'. Could not parse source: '${err instanceof Error ? err.message : String(err)}'.`);
+	}
+	if (!(parsed.program.body ?? []).some((node) => {
+		if (node.type === "ExportDefaultDeclaration") {
+			const declaration = node.declaration;
+			if (declaration?.type === "FunctionDeclaration" || declaration?.type === "FunctionExpression" || declaration?.type === "ArrowFunctionExpression") return true;
+			if (declaration?.type === "CallExpression") {
+				const call = declaration;
+				return isIdentifier(call.callee) && call.callee.name === "defineRender";
+			}
+			return false;
+		}
+		if (node.type !== "ExportNamedDeclaration") return false;
+		const declaration = node.declaration;
+		if (declaration?.type === "FunctionDeclaration") {
+			const fn = declaration;
+			return isIdentifier(fn.id) && fn.id.name === "render";
+		}
+		if (declaration?.type === "VariableDeclaration") return (declaration.declarations ?? []).some((decl) => isIdentifier(decl.id) && decl.id.name === "render");
+		return (node.specifiers ?? []).some((specifier) => {
+			const exported = specifier.exported;
+			return isIdentifier(exported) && exported.name === "render";
+		});
+	})) throw new Error(`ssr: Invalid entry '${relativePath}'. Export \`render(c, assetTags)\` or \`export default defineRender(...)\`.`);
+}
+/**
+* Validate SSR mode entry conventions.
+* Returns null when SSR mode is not used.
+*/
+function validateSsrEntries(root) {
+	const server = resolveSingleEntry(root, SSR_SERVER_ENTRY_RELATIVE_PATHS, "SSR");
+	const client = resolveSingleEntry(root, SSR_CLIENT_ENTRY_RELATIVE_PATHS, "SSR client");
+	if (!server && !client) return null;
+	if (server && !client) throw new Error(`ssr: Missing client entry. Add one of: ${SSR_CLIENT_ENTRY_RELATIVE_PATHS.join(", ")}.`);
+	if (!server && client) throw new Error(`ssr: Missing server entry. Add one of: ${SSR_SERVER_ENTRY_RELATIVE_PATHS.join(", ")}.`);
+	validateServerRenderExport(server);
+	return {
+		server,
+		client
+	};
+}
+function validateSsrEntry(root) {
+	return validateSsrEntries(root)?.server.absolutePath ?? null;
+}
+//#endregion
+//#region src/plugin-inference.ts
+const SOURCE_GLOB = "**/*.{ts,tsx,mts,js,jsx,mjs,astro}";
+/** Directories to scan for binding inference in framework mode. */
+const FRAMEWORK_SCAN_DIRS = [
+	"src",
+	"app",
+	"pages",
+	"routes",
+	"server",
+	"crons",
+	"queues"
+];
+/** Directories to scan for binding inference in Void app mode. */
+const DEFAULT_SCAN_DIRS = [
+	"routes",
+	"middleware",
+	"queues",
+	"pages",
+	"crons",
+	"src"
+];
+/**
+* Map from npm package name to framework identifier.
+* Only packages that unambiguously indicate framework mode are listed.
+* For example, `react-router` alone is a client-side router — only
+* `@react-router/dev` signals the framework (Vite plugin) mode.
+*/
+const FRAMEWORK_PACKAGES = {
+	"@tanstack/react-start": {
+		name: "tanstack-start",
+		class: "a"
+	},
+	"@react-router/dev": {
+		name: "react-router",
+		class: "a"
+	},
+	vinext: {
+		name: "vinext-pages",
+		class: "a"
+	},
+	"@sveltejs/kit": {
+		name: "sveltekit",
+		class: "b"
+	},
+	nuxt: {
+		name: "nuxt",
+		class: "c"
+	},
+	"@analogjs/platform": {
+		name: "analog",
+		class: "c"
+	},
+	astro: {
+		name: "astro",
+		class: "c"
+	}
+};
+/**
+* Detect a meta-framework by checking package.json dependencies.
+* Returns the detected framework with class info, or `undefined`.
+*/
+function detectFramework(root) {
+	let pkg;
+	try {
+		pkg = JSON.parse(readFileSync(join(root, "package.json"), "utf-8"));
+	} catch {
+		return;
+	}
+	const deps = {
+		...pkg.dependencies,
+		...pkg.devDependencies
+	};
+	for (const [pkgName, framework] of Object.entries(FRAMEWORK_PACKAGES)) if (pkgName in deps) {
+		if (framework.name === "vinext-pages" && existsSync(join(root, "app"))) return {
+			name: "vinext-app",
+			class: "a"
+		};
+		return framework;
+	}
+}
+function extractAstroFrontmatter(code) {
+	return code.match(/^\uFEFF?---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/)?.[1] ?? "";
+}
+function inferBindingsFromFile(file, code) {
+	const filename = file.split("/").pop() ?? "unknown.ts";
+	if (!filename.endsWith(".astro")) return inferBindingsFromSource(code, filename);
+	return inferBindingsFromSource(extractAstroFrontmatter(code), filename.replace(/\.astro$/, ".ts"));
+}
+/**
+* Synchronously infer which Cloudflare bindings the project needs
+* by scanning route/middleware files and optional src/main.ssr.ts with oxc-parser.
+*
+* This runs once when voidPlugin() is called (before plugins initialize),
+* so results are available to configure the Cloudflare plugin.
+*
+* @param scanDirs - Override the default scan directories (e.g., for framework mode)
+*/
+function inferProjectBindings(root, options, scanDirs) {
+	if (options?.bindings) return {
+		needsD1: Boolean(options.bindings.db),
+		needsKV: Boolean(options.bindings.kv),
+		needsR2: Boolean(options.bindings.storage),
+		needsAuth: false,
+		needsQueues: false,
+		needsAI: Boolean(options.bindings.ai),
+		needsSandbox: false,
+		needsLive: false
+	};
+	const dirs = scanDirs ?? DEFAULT_SCAN_DIRS;
+	const allBindings = [];
+	for (const dir of dirs) {
+		const dirPath = join(root, dir);
+		let files;
+		try {
+			files = globSync(SOURCE_GLOB, {
+				cwd: dirPath,
+				absolute: true
+			});
+		} catch {
+			continue;
+		}
+		for (const file of files) {
+			const code = readFileSync(file, "utf-8");
+			allBindings.push(inferBindingsFromFile(file, code));
+		}
+	}
+	const ssrEntry = getSsrServerEntryPath(root);
+	if (ssrEntry) {
+		const code = readFileSync(ssrEntry, "utf-8");
+		const filename = ssrEntry.split("/").pop() ?? "main.ssr.ts";
+		allBindings.push(inferBindingsFromSource(code, filename));
+	}
+	if (!new Set(dirs).has("src")) {
+		const srcPath = join(root, "src");
+		let srcFiles;
+		try {
+			srcFiles = globSync(SOURCE_GLOB, {
+				cwd: srcPath,
+				absolute: true
+			});
+		} catch {
+			srcFiles = [];
+		}
+		for (const file of srcFiles) {
+			const code = readFileSync(file, "utf-8");
+			allBindings.push(inferBindingsFromFile(file, code));
+		}
+	}
+	return mergeBindings(allBindings);
+}
+//#endregion
+export { SSR_CLIENT_ENTRY_RELATIVE_PATHS as a, validateSsrEntries as c, isCallExpression as d, isIdentifier as f, walk as g, isObjectExpression as h, inferProjectBindings as i, validateSsrEntry as l, isMemberExpression as m, FRAMEWORK_SCAN_DIRS as n, SSR_SERVER_ENTRY_RELATIVE_PATHS as o, isLiteral as p, detectFramework as r, hasSsrEntry as s, DEFAULT_SCAN_DIRS as t, inferBindingsFromSource as u };

package/dist/{prepare-PqAbhLte.mjs → prepare-CKzO06-Z.mjs}

@@ -2,10 +2,10 @@ import { a as join } from "./pathe.M-eThtNZ-D-kmWkCS.mjs";
 import { n as cliTitle } from "./output-BwlcIYSR.mjs";
 import { n as loadVoidAuthConfig, t as findVoidAuthConfig } from "./config-CvHtTM0q.mjs";
 import { c as R, g as ge, u as Se, y as ye } from "./dist-Dayj3gCK.mjs";
-import { c as getDatabaseDialect, f as readConfig } from "./config-BIa9HwVX.mjs";
-import { t as scanRoutes } from "./scan-QtRTdh94.mjs";
-import { i as inferProjectBindings, n as FRAMEWORK_SCAN_DIRS, r as detectFramework } from "./plugin-inference-CCtRkt9O.mjs";
-import { i as generateDbDts, n as generateQueueTypes, t as generateRouteTypes } from "./route-types-DReF1gUY.mjs";
+import { c as getDatabaseDialect, f as readConfig } from "./config-DqkeX_Fa.mjs";
+import { t as scanRoutes } from "./scan-B8iEm8xn.mjs";
+import { i as inferProjectBindings, n as FRAMEWORK_SCAN_DIRS, r as detectFramework } from "./plugin-inference-CXUuq0aC.mjs";
+import { i as generateDbDts, n as generateQueueTypes, t as generateRouteTypes } from "./route-types-Cnqj_8a7.mjs";
 import { n as ensureProjectTsconfig } from "./project-tsconfig-DfkESbDL.mjs";
 import { t as discoverSchema } from "./discover-B7FkXBLB.mjs";
 import { n as generateEnvTypes, t as findEnvFile } from "./env-types-DknSA4SO.mjs";

package/dist/{preset-jKn1hQwP.mjs → preset-BhnZpb7t.mjs}

@@ -1,5 +1,5 @@
 import { a as join, s as resolve } from "./pathe.M-eThtNZ-D-kmWkCS.mjs";
-import { s as hasSsrEntry } from "./plugin-inference-CCtRkt9O.mjs";
+import { s as hasSsrEntry } from "./plugin-inference-CXUuq0aC.mjs";
 import { existsSync, readFileSync } from "node:fs";
 //#region src/cli/preset.ts
 /**

package/dist/{protocol-DxGzKEz2.d.mts → protocol-D7r_deVZ.d.mts}

@@ -1,10 +1,11 @@
-import { n as HeadDescriptor, t as HeadConfig } from "./head-CZGAunBV.mjs";
-import { n as CloudContext, t as CloudBindings } from "./handler-dKQWyF-G.mjs";
+import { n as HeadDescriptor, t as HeadConfig } from "./head-C7QW7UY1.mjs";
+import { n as CloudContext, t as CloudBindings } from "./handler-DJTuxB10.mjs";
+import { t as DevCssAsset } from "./types-DG_Ynnyd.mjs";
 
 //#region src/pages/protocol.d.ts
 /** Escape characters that are unsafe inside inline <script> tags to prevent XSS. */
 declare function safeJsonStringify(value: unknown): string;
-interface PageObject {
+type PageObject = {
   component: string;
   props: Record<string, unknown>;
   params: Record<string, string>;
@@ -14,7 +15,7 @@ interface PageObject {
   head?: HeadDescriptor;
   deferred?: Array<string>;
   deferredKeys?: Record<string, string>;
-}
+};
 type PageRenderResult = string | ReadableStream<Uint8Array>;
 type PageHandler = ((c: CloudContext) => unknown | Promise<unknown>) | undefined;
 type PageHeadHandler = ((c: CloudContext, props: Record<string, unknown>) => HeadDescriptor | undefined) | undefined;
@@ -22,6 +23,8 @@ type AssetTags = {
   css: string;
   preloads: string;
   body: string;
+  devCss?: Array<DevCssAsset>;
+  devCssNonce?: string;
 };
 type RenderPage = (pageObj: PageObject, assetTags: AssetTags) => Promise<PageRenderResult>;
 type GetAssetTags = (req: Request, env: CloudBindings, componentId: string) => Promise<AssetTags>;

package/dist/{route-types-DReF1gUY.mjs → route-types-Cnqj_8a7.mjs}

@@ -90,14 +90,14 @@ function generateRouteTypes(scan, routesDir, outDir, pagesDir) {
 	const lines = [];
 	lines.push("// Auto-generated by void — do not edit");
 	lines.push("export {}");
-	lines.push("interface StandardSchemaV1<Input = unknown, Output = Input> {");
+	lines.push("type StandardSchemaV1<Input = unknown, Output = Input> = {");
 	lines.push("  readonly \"~standard\": {");
 	lines.push("    readonly version: 1;");
 	lines.push("    readonly vendor: string;");
 	lines.push("    readonly validate: (value: unknown) => unknown;");
 	lines.push("    readonly types?: { readonly input: Input; readonly output: Output } | undefined;");
 	lines.push("  };");
-	lines.push("}");
+	lines.push("};");
 	lines.push("declare namespace StandardSchemaV1 {");
 	lines.push("  type InferInput<Schema extends StandardSchemaV1> = NonNullable<");
 	lines.push("    Schema[\"~standard\"][\"types\"]");