@stratal/inertia 0.0.1 → 0.0.19

package/dist/index.mjs

@@ -1,96 +1,91 @@
-import { n as runTypeGeneration, t as findPagesDir } from "./type-generator-DlXIc6e2.mjs";
+import { n as runTypeGeneration, t as findPagesDir } from "./type-generator-C5JljyzK.mjs";
+import { Scope, Transient, inject } from "stratal/di";
+import { ApplicationError } from "stratal/errors";
+import { I18N_TOKENS } from "stratal/i18n";
 import { Module } from "stratal/module";
-import { Route, RouterContext } from "stratal/router";
+import { Delete, Get, Patch, Post, Put, ROUTER_TOKENS, Route, RouterContext, SchemaValidationError } from "stratal/router";
+import { spawn } from "node:child_process";
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { join, relative } from "node:path";
+import { dirname, join, relative } from "node:path";
 import { Command } from "stratal/quarry";
 import { watch } from "node:fs/promises";
-import { Transient, inject } from "stratal/di";
+import { LOGGER_TOKENS } from "stratal/logger";
+import { deleteCookie, getSignedCookie, setSignedCookie } from "hono/cookie";
 import { z } from "stratal/validation";
 //#region src/augment/router-context.ts
 function augmentRouterContext(resolveService) {
-	const proto = RouterContext.prototype;
-	const originalRedirect = proto.redirect;
-	proto.redirect = function(url, status) {
+	const originalRedirect = RouterContext.prototype.redirect;
+	RouterContext.macro("redirect", function(url, status) {
 		if (!status || status === 302) {
 			const method = this.c.req.method;
 			if (method !== "GET" && method !== "HEAD") return originalRedirect.call(this, url, 303);
 		}
 		return originalRedirect.call(this, url, status);
-	};
-	proto.inertia = function(component, props, options) {
+	});
+	RouterContext.macro("inertia", function(component, props, options) {
 		return resolveService(this).render(this, component, props, options);
-	};
-	proto.defer = function(callback, group) {
+	});
+	RouterContext.macro("defer", function(callback, group) {
 		return resolveService(this).defer(callback, group);
-	};
-	proto.optional = function(callback) {
+	});
+	RouterContext.macro("optional", function(callback) {
 		return resolveService(this).optional(callback);
-	};
-	proto.merge = function(callback) {
-		return resolveService(this).merge(callback);
-	};
-	proto.withoutSsr = function() {
+	});
+	RouterContext.macro("merge", function(callback, options) {
+		return resolveService(this).merge(callback, options);
+	});
+	RouterContext.macro("once", function(callback, options) {
+		return resolveService(this).once(callback, options);
+	});
+	RouterContext.macro("always", function(callback) {
+		return resolveService(this).always(callback);
+	});
+	RouterContext.macro("flash", function(key, value) {
+		const flashOut = this.c.get("inertiaFlashOut");
+		if (flashOut) flashOut[key] = value;
+	});
+	RouterContext.macro("withoutSsr", function() {
 		this.c.set("withoutSsr", true);
-	};
+	});
 }
 //#endregion
 //#region src/vite/create-vite-config.ts
-async function createInertiaViteConfig(options) {
-	const { mergeConfig } = await import("vite");
-	let userConfig = {};
-	const viteConfigPath = join(options.cwd, "vite.config.ts");
-	if (existsSync(viteConfigPath)) {
-		const loaded = await import(
-			/* @vite-ignore */
-			viteConfigPath
-);
-		userConfig = loaded.default ?? loaded;
-	}
-	const { cloudflare } = await import("@cloudflare/vite-plugin");
-	const { stratalInertiaDevCss } = await import("./inertia-dev-css-plugin-BYromyO_.mjs").then((n) => n.t);
-	const { stratalInertiaTypes } = await import("./inertia-types-plugin-NO_uxhxQ.mjs").then((n) => n.t);
-	const hasInertiaPlugin = (Array.isArray(userConfig.plugins) ? userConfig.plugins.flat() : []).some((p) => p && typeof p === "object" && "name" in p && p.name === "inertia");
-	const inertiaPlugins = [];
-	if (!hasInertiaPlugin) try {
-		const { default: inertia } = await import("@inertiajs/vite");
-		inertiaPlugins.push(inertia({ pages: {
-			path: "./src/inertia/pages",
-			extension: ".tsx"
-		} }));
-	} catch {}
-	const optimizeDepsExclude = [
-		"@cloudflare/vite-plugin",
-		"wrangler",
-		"blake3-wasm"
-	];
-	return mergeConfig({
-		plugins: [
-			cloudflare(),
-			...inertiaPlugins,
-			stratalInertiaDevCss({ entries: ["/" + options.entryPath] }),
-			stratalInertiaTypes(),
-			{
-				name: "stratal:optimize-deps-fix",
-				configEnvironment(_name, env) {
-					const existing = env.optimizeDeps?.exclude ?? [];
-					env.optimizeDeps = {
-						...env.optimizeDeps,
-						exclude: [...existing, ...optimizeDepsExclude]
-					};
-				}
-			}
-		],
-		publicDir: join(options.cwd, "src", "inertia", "public"),
-		build: {
-			...options.outDir ? { outDir: options.outDir } : {},
-			rolldownOptions: { input: options.entryPath }
-		},
-		...options.server ? { server: {
-			port: options.server.port,
-			host: options.server.host ?? void 0
-		} } : {}
-	}, userConfig);
+function writeTempViteConfig(options) {
+	const configPath = join(join(options.cwd, "node_modules", ".stratal"), "vite.config.mjs");
+	mkdirSync(dirname(configPath), { recursive: true });
+	const hasUserConfig = existsSync(join(options.cwd, "vite.config.ts"));
+	const serverConfig = options.server ? `server: { port: ${options.server.port}, host: ${options.server.host ? "true" : "undefined"} },` : "";
+	const outDirConfig = options.outDir ? `outDir: '${options.outDir}',` : "";
+	writeFileSync(configPath, `
+import { mergeConfig } from 'vite'
+import { cloudflare } from '@cloudflare/vite-plugin'
+import { stratalInertia } from '@stratal/inertia/vite'
+
+let inertiaPlugin = null
+try {
+  const mod = await import('@inertiajs/vite')
+  const inertia = mod.default ?? mod
+  inertiaPlugin = inertia()
+} catch {}
+
+const baseConfig = {
+  plugins: [
+    cloudflare(${options.persistTo ? `{ persistState: { path: ${JSON.stringify(options.persistTo)} } }` : ""}),
+    ...(inertiaPlugin ? [inertiaPlugin] : []),
+    ...stratalInertia(),
+  ],
+  publicDir: '${join(options.cwd, "src", "inertia", "public").replace(/\\/g, "/")}',
+  build: {
+    ${outDirConfig}
+  },
+  ${serverConfig}
+}
+
+${hasUserConfig ? `const userModule = await import('${join(options.cwd, "vite.config.ts").replace(/\\/g, "/")}')
+const userConfig = userModule.default ?? userModule
+export default mergeConfig(baseConfig, userConfig)` : "export default baseConfig"}
+`, "utf-8");
+	return configPath;
 }
 //#endregion
 //#region src/commands/inertia-build.command.ts
@@ -101,72 +96,100 @@ var InertiaBuildCommand = class extends Command {
 		const outDir = this.string("outDir") || "dist";
 		const shouldBuildSsr = this.boolean("ssr");
 		const cwd = process.cwd();
-		const entryPath = "src/inertia/app.tsx";
-		if (!existsSync(join(cwd, entryPath))) {
+		if (!existsSync(join(cwd, "src/inertia/app.tsx"))) {
 			this.fail("src/inertia/app.tsx not found. Run `quarry inertia:install` first.");
 			return 1;
 		}
+		const configPath = writeTempViteConfig({
+			cwd,
+			outDir
+		});
 		this.info("Building Inertia.js frontend for production...");
-		try {
-			const { build } = await import("vite");
-			const config = await createInertiaViteConfig({
-				cwd,
-				entryPath,
-				outDir
-			});
-			await build(config);
-			this.success("Client build complete!");
-			if (shouldBuildSsr) {
-				this.info("Building SSR bundle...");
-				await build({
-					...config,
-					build: {
-						...config.build,
-						ssr: true
-					}
-				});
-				this.success("SSR build complete!");
+		const clientCode = await this.spawnVite(cwd, configPath, ["build"]);
+		if (clientCode !== 0) {
+			this.fail("Client build failed.");
+			return clientCode;
+		}
+		this.success("Client build complete!");
+		if (shouldBuildSsr) {
+			this.info("Building SSR bundle...");
+			const ssrCode = await this.spawnVite(cwd, configPath, ["build", "--ssr"]);
+			if (ssrCode !== 0) {
+				this.fail("SSR build failed.");
+				return ssrCode;
 			}
-			this.success(`Output in ${outDir}/`);
-		} catch (err) {
-			this.fail(`Build failed: ${err.message}`);
-			return 1;
+			this.success("SSR build complete!");
 		}
+		this.success(`Output in ${outDir}/`);
+		this.info("Deploy with: npx wrangler deploy");
 		return 0;
 	}
+	spawnVite(cwd, configPath, args) {
+		return new Promise((resolve) => {
+			const child = spawn("npx", [
+				"vite",
+				"--config",
+				configPath,
+				...args
+			], {
+				cwd,
+				stdio: "inherit",
+				shell: true
+			});
+			child.on("error", (err) => {
+				this.fail(`Vite process error: ${err.message}`);
+				resolve(1);
+			});
+			child.on("close", (code) => {
+				resolve(code ?? 0);
+			});
+		});
+	}
 };
 //#endregion
 //#region src/commands/inertia-dev.command.ts
 var InertiaDevCommand = class extends Command {
-	static command = "inertia:dev {--port=5173 : Dev server port} {--host : Expose to network}";
+	static command = "inertia:dev {--port= : Dev server port} {--host : Expose to network} {--persist-to= : Shared persist directory for @cloudflare/vite-plugin (relative to cwd; the plugin appends /v3). Use to share R2/KV/cache emulator state across multiple workers in dev.}";
 	static description = "Start Inertia.js Vite development server";
 	async handle() {
-		const port = this.number("port") || 5173;
+		const port = this.number("port");
 		const host = this.boolean("host");
+		const persistTo = this.string("persist-to");
 		const cwd = process.cwd();
-		const entryPath = "src/inertia/app.tsx";
-		if (!existsSync(join(cwd, entryPath))) {
+		if (!existsSync(join(cwd, "src/inertia/app.tsx"))) {
 			this.fail("src/inertia/app.tsx not found. Run `quarry inertia:install` first.");
 			return 1;
 		}
+		const configPath = writeTempViteConfig({
+			cwd,
+			server: {
+				port,
+				host
+			},
+			persistTo
+		});
 		this.info("Starting Vite dev server...");
-		try {
-			const { createServer } = await import("vite");
-			const server = await createServer(await createInertiaViteConfig({
+		const args = [
+			"vite",
+			"dev",
+			"--config",
+			configPath
+		];
+		if (host) args.push("--host");
+		return new Promise((resolve) => {
+			const child = spawn("npx", args, {
 				cwd,
-				entryPath,
-				server: {
-					port,
-					host
-				}
-			}));
-			await server.listen();
-			server.printUrls();
-		} catch (err) {
-			this.fail(`Failed to start dev server: ${err.message}`);
-			return 1;
-		}
-		return 0;
+				stdio: "inherit",
+				shell: true
+			});
+			child.on("error", (err) => {
+				this.fail(`Failed to start dev server: ${err.message}`);
+				resolve(1);
+			});
+			child.on("close", (code) => {
+				resolve(code ?? 0);
+			});
+		});
 	}
 };
 //#endregion
@@ -186,7 +209,14 @@ const ROOT_HTML = `<!DOCTYPE html>
 </html>`;
 const APP_TSX = `import { createInertiaApp } from '@inertiajs/react'
 
-createInertiaApp()`;
+createInertiaApp({
+  resolve: async (name) => {
+    const pages = import.meta.glob('./pages/**/*.tsx')
+    const page = await pages[\`./pages/\${name}.tsx\`]?.()
+    if (!page) throw new Error(\`Page not found: \${name}\`)
+    return page
+  },
+})`;
 const HOME_TSX = `export default function Home({ message }: { message: string }) {
   return (
     <div>
@@ -302,15 +332,14 @@ var InertiaTypesCommand = class extends Command {
 	static description = "Generate Inertia.js page type definitions";
 	async handle() {
 		const cwd = process.cwd();
-		const pagesDir = findPagesDir(cwd);
-		if (!existsSync(pagesDir)) {
+		if (!existsSync(findPagesDir(cwd))) {
 			this.fail("src/inertia/pages/ not found. Run `quarry inertia:install` first.");
 			return 1;
 		}
 		if (!await this.generate(cwd)) return 1;
 		if (this.boolean("watch")) {
 			this.info("Watching for changes...");
-			await this.watchForChanges(cwd, pagesDir);
+			await this.watchForChanges(cwd);
 		}
 		return 0;
 	}
@@ -325,9 +354,10 @@ var InertiaTypesCommand = class extends Command {
 			return false;
 		}
 	}
-	async watchForChanges(cwd, pagesDir) {
+	async watchForChanges(cwd) {
+		const srcDir = join(cwd, "src");
 		try {
-			const watcher = watch(pagesDir, { recursive: true });
+			const watcher = watch(srcDir, { recursive: true });
 			for await (const event of watcher) if (event.filename && /\.(tsx|ts)$/.test(event.filename)) {
 				this.info(`Change detected: ${event.filename}`);
 				await this.generate(cwd);
@@ -347,19 +377,19 @@ const INERTIA_TOKENS = {
 	SsrRenderer: Symbol.for("stratal:inertia:ssr-renderer")
 };
 //#endregion
-//#region \0@oxc-project+runtime@0.115.0/helpers/decorateMetadata.js
+//#region \0@oxc-project+runtime@0.127.0/helpers/decorateMetadata.js
 function __decorateMetadata(k, v) {
 	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.115.0/helpers/decorateParam.js
+//#region \0@oxc-project+runtime@0.127.0/helpers/decorateParam.js
 function __decorateParam(paramIndex, decorator) {
 	return function(target, key) {
 		decorator(target, key, paramIndex);
 	};
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.115.0/helpers/decorate.js
+//#region \0@oxc-project+runtime@0.127.0/helpers/decorate.js
 function __decorate(decorators, target, key, desc) {
 	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
 	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -378,6 +408,13 @@ let InertiaMiddleware = class InertiaMiddleware {
 		ctx.c.set("inertia", isInertia);
 		ctx.c.set("inertiaPrefetch", isPrefetch);
 		ctx.c.set("withoutSsr", false);
+		ctx.c.set("inertiaFlashOut", {});
+		let hadFlash = false;
+		if (this.options.flash) {
+			const flashData = await this.options.flash.store.read(ctx);
+			hadFlash = Object.keys(flashData).length > 0;
+			ctx.c.set("inertiaFlash", flashData);
+		} else ctx.c.set("inertiaFlash", {});
 		if (isInertia && ctx.c.req.method === "GET") {
 			const clientVersion = ctx.header("x-inertia-version");
 			const serverVersion = this.options.version ?? "";
@@ -388,6 +425,11 @@ let InertiaMiddleware = class InertiaMiddleware {
 			}
 		}
 		await next();
+		if (this.options.flash) {
+			const flashOut = ctx.c.get("inertiaFlashOut");
+			if (Object.keys(flashOut).length > 0) await this.options.flash.store.write(ctx, flashOut);
+			else if (hadFlash) await this.options.flash.store.clear(ctx);
+		}
 		ctx.c.header("Vary", "X-Inertia");
 		if (isInertia) {
 			const method = ctx.c.req.method;
@@ -405,6 +447,8 @@ InertiaMiddleware = __decorate([
 const INERTIA_PROP_OPTIONAL = Symbol.for("stratal:inertia:prop:optional");
 const INERTIA_PROP_DEFERRED = Symbol.for("stratal:inertia:prop:deferred");
 const INERTIA_PROP_MERGE = Symbol.for("stratal:inertia:prop:merge");
+const INERTIA_PROP_ONCE = Symbol.for("stratal:inertia:prop:once");
+const INERTIA_PROP_ALWAYS = Symbol.for("stratal:inertia:prop:always");
 //#endregion
 //#region src/services/inertia.service.ts
 let InertiaService = class InertiaService {
@@ -436,30 +480,63 @@ let InertiaService = class InertiaService {
 			group
 		};
 	}
-	merge(callback) {
+	merge(callback, options) {
 		return {
 			[INERTIA_PROP_MERGE]: true,
+			callback,
+			strategy: options?.strategy ?? "append",
+			matchOn: options?.matchOn
+		};
+	}
+	once(callback, options) {
+		return {
+			[INERTIA_PROP_ONCE]: true,
+			callback,
+			expiresAt: options?.expiresAt ?? null,
+			key: options?.key
+		};
+	}
+	always(callback) {
+		return {
+			[INERTIA_PROP_ALWAYS]: true,
 			callback
 		};
 	}
 	async render(ctx, component, props = {}, renderOptions = {}) {
-		const url = new URL(ctx.c.req.url).pathname;
+		const reqUrl = new URL(ctx.c.req.url);
+		const url = reqUrl.search ? `${reqUrl.pathname}${reqUrl.search}` : reqUrl.pathname;
 		const isInertia = ctx.c.get("inertia");
+		const { shared: resolvedShared, sharedKeys } = await this.resolveSharedData(ctx);
 		const allProps = {
-			...await this.resolveSharedData(ctx),
+			...resolvedShared,
 			...this.sharedData,
 			...props
 		};
-		const { resolvedProps, mergeProps, deferredProps } = await this.processProps(allProps, ctx, component, isInertia);
+		const allSharedKeys = [...sharedKeys, ...Object.keys(this.sharedData)];
+		const result = await this.processProps(allProps, ctx, component, isInertia);
+		const { errors: flashErrors, ...flash } = ctx.c.get("inertiaFlash") ?? {};
+		const errors = flashErrors && typeof flashErrors === "object" && !Array.isArray(flashErrors) ? flashErrors : {};
 		const page = {
 			component,
-			props: resolvedProps,
+			props: {
+				...result.resolvedProps,
+				errors
+			},
 			url,
-			version: this.options.version ?? "",
-			mergeProps,
-			deferredProps,
+			version: this.options.version ?? null,
+			flash,
+			rememberedState: {},
+			...result.mergeProps.length > 0 ? { mergeProps: result.mergeProps } : {},
+			...result.prependProps.length > 0 ? { prependProps: result.prependProps } : {},
+			...result.deepMergeProps.length > 0 ? { deepMergeProps: result.deepMergeProps } : {},
+			...result.matchPropsOn.length > 0 ? { matchPropsOn: result.matchPropsOn } : {},
+			...Object.keys(result.deferredProps).length > 0 ? { deferredProps: result.deferredProps } : {},
+			...Object.keys(result.deferredProps).length > 0 && !this.isPartialReload(ctx, component) ? { initialDeferredProps: result.deferredProps } : {},
+			...Object.keys(result.onceProps).length > 0 ? { onceProps: result.onceProps } : {},
+			...allSharedKeys.length > 0 ? { sharedProps: allSharedKeys } : {},
 			...renderOptions.encryptHistory ? { encryptHistory: true } : {},
-			...renderOptions.clearHistory ? { clearHistory: true } : {}
+			...renderOptions.clearHistory ? { clearHistory: true } : {},
+			...renderOptions.preserveFragment ? { preserveFragment: true } : {}
 		};
 		if (isInertia) return new Response(JSON.stringify(page), {
 			status: 200,
@@ -479,23 +556,71 @@ let InertiaService = class InertiaService {
 			headers: { "Content-Type": "text/html; charset=utf-8" }
 		});
 	}
+	/**
+	* Resolve shared data from module options and i18n configuration.
+	*
+	* Processes static values and resolver functions from `sharedData` config.
+	* When `i18n` option is set, auto-injects `locale` and `translations` props
+	* using the core {@link MessageLoaderService} resolved from the request container.
+	*/
 	async resolveSharedData(ctx) {
 		const shared = {};
 		const configShared = this.options.sharedData;
-		if (!configShared) return shared;
-		for (const [key, value] of Object.entries(configShared)) if (typeof value === "function") shared[key] = await value(ctx);
+		if (configShared) for (const [key, value] of Object.entries(configShared)) if (typeof value === "function") shared[key] = await value(ctx);
 		else shared[key] = value;
-		return shared;
+		if (this.options.i18n) {
+			const loader = ctx.getContainer().resolve(I18N_TOKENS.MessageLoader);
+			const locale = ctx.getLocale();
+			shared.locale = locale;
+			shared.translations = loader.getFilteredMessages(locale, { only: this.options.i18n.only });
+		}
+		if (this.options.routes) {
+			const registry = ctx.getContainer().resolve(ROUTER_TOKENS.RouteRegistry);
+			shared.routes = this.serializeRoutes(registry.named());
+		}
+		return {
+			shared,
+			sharedKeys: Object.keys(shared)
+		};
+	}
+	isPartialReload(ctx, component) {
+		const isInertia = ctx.c.get("inertia");
+		const partialComponent = ctx.header("x-inertia-partial-component");
+		const partialDataHeader = ctx.header("x-inertia-partial-data");
+		return !!(isInertia && partialComponent === component && partialDataHeader);
 	}
 	async processProps(allProps, ctx, component, isInertia) {
 		const resolvedProps = {};
 		const mergeProps = [];
+		const prependProps = [];
+		const deepMergeProps = [];
+		const matchPropsOn = [];
 		const deferredProps = {};
+		const onceProps = {};
 		const partialComponent = ctx.header("x-inertia-partial-component");
 		const partialDataHeader = ctx.header("x-inertia-partial-data");
+		const partialExceptHeader = ctx.header("x-inertia-partial-except");
+		const resetHeader = ctx.header("x-inertia-reset");
 		const isPartialReload = isInertia && partialComponent === component && partialDataHeader;
 		const requestedProps = partialDataHeader?.split(",").map((s) => s.trim()) ?? [];
+		const exceptProps = partialExceptHeader?.split(",").map((s) => s.trim()) ?? [];
+		resetHeader?.split(",").map((s) => s.trim());
 		for (const [key, value] of Object.entries(allProps)) {
+			if (this.isAlwaysProp(value)) {
+				resolvedProps[key] = await value.callback();
+				continue;
+			}
+			if (this.isOnceProp(value)) {
+				if (isPartialReload && this.isRequested(key, requestedProps)) resolvedProps[key] = await value.callback();
+				else if (!isPartialReload) {
+					resolvedProps[key] = await value.callback();
+					onceProps[key] = {
+						prop: value.key ?? key,
+						...value.expiresAt != null ? { expiresAt: value.expiresAt } : {}
+					};
+				}
+				continue;
+			}
 			if (this.isDeferredProp(value)) {
 				if (isPartialReload && this.isRequested(key, requestedProps)) resolvedProps[key] = await value.callback();
 				else if (!isPartialReload) {
@@ -506,7 +631,18 @@ let InertiaService = class InertiaService {
 			}
 			if (this.isMergeProp(value)) {
 				if (isPartialReload && !this.isRequested(key, requestedProps)) continue;
-				mergeProps.push(key);
+				switch (value.strategy) {
+					case "prepend":
+						prependProps.push(key);
+						break;
+					case "deep":
+						deepMergeProps.push(key);
+						break;
+					default:
+						mergeProps.push(key);
+						break;
+				}
+				if (value.matchOn) matchPropsOn.push(`${key}:${value.matchOn}`);
 				resolvedProps[key] = await value.callback();
 				continue;
 			}
@@ -515,13 +651,17 @@ let InertiaService = class InertiaService {
 				continue;
 			}
 			if (isPartialReload) {
-				if (this.isRequested(key, requestedProps)) resolvedProps[key] = value;
+				if (this.isRequested(key, requestedProps) && !this.isExcepted(key, exceptProps)) resolvedProps[key] = value;
 			} else resolvedProps[key] = value;
 		}
 		return {
 			resolvedProps,
 			mergeProps,
-			deferredProps
+			prependProps,
+			deepMergeProps,
+			matchPropsOn,
+			deferredProps,
+			onceProps
 		};
 	}
 	/**
@@ -531,6 +671,9 @@ let InertiaService = class InertiaService {
 	isRequested(key, requestedProps) {
 		return requestedProps.some((prop) => prop === key || prop.startsWith(`${key}.`));
 	}
+	isExcepted(key, exceptProps) {
+		return exceptProps.some((prop) => prop === key || prop.startsWith(`${key}.`));
+	}
 	isOptionalProp(value) {
 		return typeof value === "object" && value !== null && INERTIA_PROP_OPTIONAL in value;
 	}
@@ -540,6 +683,23 @@ let InertiaService = class InertiaService {
 	isMergeProp(value) {
 		return typeof value === "object" && value !== null && INERTIA_PROP_MERGE in value;
 	}
+	isOnceProp(value) {
+		return typeof value === "object" && value !== null && INERTIA_PROP_ONCE in value;
+	}
+	isAlwaysProp(value) {
+		return typeof value === "object" && value !== null && INERTIA_PROP_ALWAYS in value;
+	}
+	serializeRoutes(routes) {
+		const serialized = {};
+		for (const route of routes) if (route.name) serialized[route.name] = {
+			path: route.path,
+			paramNames: route.paramNames,
+			domainParamNames: route.domainParamNames,
+			...route.domain ? { domain: route.domain } : {},
+			...route.localePaths?.length ? { localePaths: route.localePaths } : {}
+		};
+		return serialized;
+	}
 	isSsrDisabled(pathname) {
 		const patterns = this.options.ssr?.disabled;
 		if (!patterns || patterns.length === 0) return false;
@@ -550,7 +710,7 @@ let InertiaService = class InertiaService {
 	}
 };
 InertiaService = __decorate([
-	Transient(),
+	Transient(INERTIA_TOKENS.InertiaService),
 	__decorateParam(0, inject(INERTIA_TOKENS.Options)),
 	__decorateParam(1, inject(INERTIA_TOKENS.TemplateService)),
 	__decorateParam(2, inject(INERTIA_TOKENS.SsrRenderer)),
@@ -611,8 +771,9 @@ ManifestService = __decorate([
 let SsrRendererService = class SsrRendererService {
 	bundle = null;
 	loadPromise = null;
-	constructor(options) {
+	constructor(options, logger) {
 		this.options = options;
+		this.logger = logger;
 	}
 	async render(page) {
 		if (!this.options.ssr) return {
@@ -637,8 +798,10 @@ let SsrRendererService = class SsrRendererService {
 		if (!this.options.ssr) return;
 		try {
 			const mod = await this.options.ssr.bundle();
-			this.bundle = "default" in mod ? mod.default : mod;
-		} catch {
+			const resolved = "default" in mod ? mod.default : mod;
+			this.bundle = resolved;
+		} catch (error) {
+			this.logger.warn("[stratal:inertia] Failed to load SSR bundle. Falling back to client-side rendering.", { error });
 			this.loadPromise = null;
 		}
 	}
@@ -646,7 +809,8 @@ let SsrRendererService = class SsrRendererService {
 SsrRendererService = __decorate([
 	Transient(),
 	__decorateParam(0, inject(INERTIA_TOKENS.Options)),
-	__decorateMetadata("design:paramtypes", [Object])
+	__decorateParam(1, inject(LOGGER_TOKENS.LoggerService)),
+	__decorateMetadata("design:paramtypes", [Object, Object])
 ], SsrRendererService);
 //#endregion
 //#region src/services/template.service.ts
@@ -700,19 +864,86 @@ let InertiaModule = _InertiaModule = class InertiaModule {
 			}]
 		};
 	}
-	configure(consumer) {
-		consumer.apply(InertiaMiddleware).forRoutes("*");
+	configureRoutes(router) {
+		router.use(InertiaMiddleware);
+	}
+	onException(handler) {
+		handler.renderable(SchemaValidationError, (error, context) => {
+			if (context.type !== "http") return void 0;
+			if (this.isPrecognitionRequest(context)) return this.handlePrecognitionValidationError(error, context);
+			if (!this.isInertiaRequest(context)) return void 0;
+			const issues = error.metadata?.issues ?? [];
+			const errors = {};
+			for (const issue of issues) errors[issue.path] = issue.message;
+			context.ctx.flash("errors", errors);
+			return this.redirectBack(context);
+		});
+		handler.renderable(ApplicationError, (error, context) => {
+			if (context.type !== "http") return void 0;
+			const message = context.ctx.getContainer().resolve(I18N_TOKENS.I18nService).t(error.message, error.metadata);
+			if (this.isPrecognitionRequest(context)) return this.createPrecognitionErrorResponse({ _form: message });
+			if (!this.isInertiaRequest(context)) return void 0;
+			context.ctx.flash("errors", { _form: message });
+			return this.redirectBack(context);
+		});
 	}
 	onInitialize() {
 		augmentRouterContext((ctx) => {
 			return ctx.getContainer().resolve(INERTIA_TOKENS.InertiaService);
 		});
 	}
+	isInertiaRequest(context) {
+		return context.ctx.header("x-inertia") === "true";
+	}
+	isPrecognitionRequest(context) {
+		return context.ctx.header("precognition") === "true";
+	}
+	handlePrecognitionValidationError(error, context) {
+		const issues = error.metadata?.issues ?? [];
+		let errors = {};
+		for (const issue of issues) errors[issue.path] = issue.message;
+		const validateOnly = context.ctx.header("precognition-validate-only");
+		if (validateOnly) {
+			const fields = validateOnly.split(",").map((f) => f.trim());
+			const filtered = {};
+			for (const field of fields) if (errors[field]) filtered[field] = errors[field];
+			errors = filtered;
+		}
+		if (Object.keys(errors).length === 0) return new Response(null, {
+			status: 204,
+			headers: {
+				"Precognition": "true",
+				"Precognition-Success": "true",
+				"Vary": "Precognition"
+			}
+		});
+		return this.createPrecognitionErrorResponse(errors);
+	}
+	createPrecognitionErrorResponse(errors) {
+		return new Response(JSON.stringify({ errors }), {
+			status: 422,
+			headers: {
+				"Content-Type": "application/json",
+				"Precognition": "true",
+				"Vary": "Precognition"
+			}
+		});
+	}
+	redirectBack(context) {
+		const referer = context.ctx.header("referer");
+		if (referer) {
+			const parsed = new URL(referer);
+			const url = parsed.search ? `${parsed.pathname}${parsed.search}` : parsed.pathname;
+			return context.ctx.redirect(url, 303);
+		}
+		return context.ctx.redirect("/", 303);
+	}
 };
 InertiaModule = _InertiaModule = __decorate([Module({ providers: [
 	{
 		provide: INERTIA_TOKENS.InertiaService,
-		useClass: InertiaService
+		useClass: InertiaService,
+		scope: Scope.Request
 	},
 	{
 		provide: INERTIA_TOKENS.TemplateService,
@@ -724,7 +955,8 @@ InertiaModule = _InertiaModule = __decorate([Module({ providers: [
 	},
 	{
 		provide: INERTIA_TOKENS.SsrRenderer,
-		useClass: SsrRendererService
+		useClass: SsrRendererService,
+		scope: Scope.Singleton
 	},
 	InertiaInstallCommand,
 	InertiaTypesCommand,
@@ -732,28 +964,85 @@ InertiaModule = _InertiaModule = __decorate([Module({ providers: [
 	InertiaBuildCommand
 ] })], InertiaModule);
 //#endregion
-//#region src/decorators/inertia-route.decorator.ts
+//#region src/flash/cookie-flash-store.ts
+var CookieFlashStore = class {
+	cookieName;
+	secret;
+	cookieOptions;
+	constructor(options) {
+		this.secret = options.secret;
+		this.cookieName = options.cookie ?? "stratal_flash";
+		this.cookieOptions = {
+			path: "/",
+			httpOnly: true,
+			sameSite: "Lax",
+			...options.cookieOptions
+		};
+	}
+	async read(ctx) {
+		const value = await getSignedCookie(ctx.c, this.secret, this.cookieName);
+		if (!value) return {};
+		try {
+			return JSON.parse(atob(value));
+		} catch {
+			return {};
+		}
+	}
+	async write(ctx, data) {
+		const encoded = btoa(JSON.stringify(data));
+		await setSignedCookie(ctx.c, this.cookieName, encoded, this.secret, this.cookieOptions);
+	}
+	clear(ctx) {
+		deleteCookie(ctx.c, this.cookieName, { path: this.cookieOptions.path });
+		return Promise.resolve();
+	}
+};
+const inertiaResponse = {
+	schema: z.object({
+		component: z.string(),
+		props: z.record(z.string(), z.unknown()),
+		url: z.string(),
+		version: z.string().nullable(),
+		flash: z.record(z.string(), z.unknown()),
+		rememberedState: z.record(z.string(), z.unknown()),
+		mergeProps: z.array(z.string()).optional(),
+		prependProps: z.array(z.string()).optional(),
+		deepMergeProps: z.array(z.string()).optional(),
+		matchPropsOn: z.array(z.string()).optional(),
+		deferredProps: z.record(z.string(), z.array(z.string())).optional(),
+		initialDeferredProps: z.record(z.string(), z.array(z.string())).optional(),
+		onceProps: z.record(z.string(), z.object({
+			prop: z.string(),
+			expiresAt: z.number().nullable().optional()
+		})).optional(),
+		sharedProps: z.array(z.string()).optional(),
+		encryptHistory: z.boolean().optional(),
+		clearHistory: z.boolean().optional(),
+		preserveFragment: z.boolean().optional()
+	}),
+	description: "Inertia page response",
+	contentType: "text/html"
+};
 /**
-* Zod schema for the Inertia page JSON response (returned for X-Inertia XHR requests)
+* Builds a full RouteConfig from InertiaRouteConfig by applying inertia defaults.
 */
-const inertiaPageSchema = z.object({
-	component: z.string(),
-	props: z.record(z.string(), z.unknown()),
-	url: z.string(),
-	version: z.string(),
-	mergeProps: z.array(z.string()),
-	deferredProps: z.record(z.string(), z.array(z.string())),
-	encryptHistory: z.boolean(),
-	clearHistory: z.boolean()
-});
+function buildInertiaConfig(config) {
+	const { hideFromDocs = true, ...rest } = config;
+	return {
+		...rest,
+		response: inertiaResponse,
+		hideFromDocs
+	};
+}
 /**
-* Decorator for Inertia page routes.
+* Decorator for Inertia page routes using convention-based routing.
 *
 * Wraps `@Route()` with:
 * - Auto-applied Inertia page response schema
 * - `hideFromDocs: true` by default (overridable)
 *
-* Accepts `query`, `params`, `body`, `tags`, `summary`, `description`, `security`.
+* **Cannot be mixed with HTTP method decorators** (`@Get`, `@Post`, `@InertiaGet`, etc.)
+* in the same controller.
 *
 * @example
 * ```typescript
@@ -767,18 +1056,103 @@ const inertiaPageSchema = z.object({
 * ```
 */
 function InertiaRoute(config = {}) {
-	const { hideFromDocs = true, ...rest } = config;
-	return Route({
-		...rest,
-		response: {
-			schema: inertiaPageSchema,
-			description: "Inertia page response",
-			contentType: "text/html"
-		},
-		hideFromDocs
-	});
+	return Route(buildInertiaConfig(config));
 }
+/**
+* Registers a GET route for an Inertia page.
+*
+* Wraps `@Get()` with auto-applied Inertia page response schema
+* and `hideFromDocs: true` by default.
+*
+* @param path - Route path relative to the controller base path
+* @param config - Optional route configuration (query, params, tags, etc.)
+*
+* @example
+* ```typescript
+* @Controller('/notes')
+* export class NotesController {
+*   @InertiaGet('/')
+*   async index(ctx: RouterContext) {
+*     return ctx.inertia('notes/Index', { notes: [] })
+*   }
+*
+*   @InertiaGet('/:id', { params: z.object({ id: z.string() }) })
+*   async show(ctx: RouterContext) {
+*     return ctx.inertia('notes/Show', { note })
+*   }
+* }
+* ```
+*/
+function InertiaGet(path, config = {}) {
+	return Get(path, buildInertiaConfig(config));
+}
+/**
+* Registers a POST route for an Inertia form submission.
+*
+* Wraps `@Post()` with auto-applied Inertia page response schema
+* and `hideFromDocs: true` by default.
+*
+* @param path - Route path relative to the controller base path
+* @param config - Optional route configuration (body, params, tags, etc.)
+*/
+function InertiaPost(path, config = {}) {
+	return Post(path, buildInertiaConfig(config));
+}
+/**
+* Registers a PUT route for an Inertia form submission.
+*
+* Wraps `@Put()` with auto-applied Inertia page response schema
+* and `hideFromDocs: true` by default.
+*
+* @param path - Route path relative to the controller base path
+* @param config - Optional route configuration (body, params, tags, etc.)
+*/
+function InertiaPut(path, config = {}) {
+	return Put(path, buildInertiaConfig(config));
+}
+/**
+* Registers a PATCH route for an Inertia form submission.
+*
+* Wraps `@Patch()` with auto-applied Inertia page response schema
+* and `hideFromDocs: true` by default.
+*
+* @param path - Route path relative to the controller base path
+* @param config - Optional route configuration (body, params, tags, etc.)
+*/
+function InertiaPatch(path, config = {}) {
+	return Patch(path, buildInertiaConfig(config));
+}
+/**
+* Registers a DELETE route for an Inertia form submission.
+*
+* Wraps `@Delete()` with auto-applied Inertia page response schema
+* and `hideFromDocs: true` by default.
+*
+* @param path - Route path relative to the controller base path
+* @param config - Optional route configuration (params, tags, etc.)
+*/
+function InertiaDelete(path, config = {}) {
+	return Delete(path, buildInertiaConfig(config));
+}
+//#endregion
+//#region src/middleware/handle-precognitive-requests.middleware.ts
+let HandlePrecognitiveRequests = class HandlePrecognitiveRequests {
+	async handle(ctx, next) {
+		const isPrecognition = ctx.header("precognition") === "true";
+		ctx.c.set("precognition", isPrecognition);
+		if (isPrecognition) ctx.c.set("validationSuccessResponse", new Response(null, {
+			status: 204,
+			headers: {
+				"Precognition": "true",
+				"Precognition-Success": "true",
+				"Vary": "Precognition"
+			}
+		}));
+		await next();
+	}
+};
+HandlePrecognitiveRequests = __decorate([Transient()], HandlePrecognitiveRequests);
 //#endregion
-export { INERTIA_TOKENS, InertiaBuildCommand, InertiaDevCommand, InertiaInstallCommand, InertiaMiddleware, InertiaModule, InertiaRoute, InertiaService, InertiaTypesCommand, ManifestService, SsrRendererService, TemplateService, runTypeGeneration };
+export { CookieFlashStore, HandlePrecognitiveRequests, INERTIA_TOKENS, InertiaBuildCommand, InertiaDelete, InertiaDevCommand, InertiaGet, InertiaInstallCommand, InertiaMiddleware, InertiaModule, InertiaPatch, InertiaPost, InertiaPut, InertiaRoute, InertiaService, InertiaTypesCommand, ManifestService, SsrRendererService, TemplateService, runTypeGeneration };
 
 //# sourceMappingURL=index.mjs.map