@stratal/inertia 0.0.18 → 0.0.19

package/dist/index.mjs

@@ -0,0 +1,1158 @@
+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 { 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 { dirname, join, relative } from "node:path";
+import { Command } from "stratal/quarry";
+import { watch } from "node:fs/promises";
+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 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);
+	});
+	RouterContext.macro("inertia", function(component, props, options) {
+		return resolveService(this).render(this, component, props, options);
+	});
+	RouterContext.macro("defer", function(callback, group) {
+		return resolveService(this).defer(callback, group);
+	});
+	RouterContext.macro("optional", function(callback) {
+		return resolveService(this).optional(callback);
+	});
+	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
+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
+var InertiaBuildCommand = class extends Command {
+	static command = "inertia:build {--outDir=dist : Output directory} {--ssr : Also build SSR bundle}";
+	static description = "Build Inertia.js frontend for production";
+	async handle() {
+		const outDir = this.string("outDir") || "dist";
+		const shouldBuildSsr = this.boolean("ssr");
+		const cwd = process.cwd();
+		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...");
+		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("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= : 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");
+		const host = this.boolean("host");
+		const persistTo = this.string("persist-to");
+		const cwd = process.cwd();
+		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...");
+		const args = [
+			"vite",
+			"dev",
+			"--config",
+			configPath
+		];
+		if (host) args.push("--host");
+		return new Promise((resolve) => {
+			const child = spawn("npx", args, {
+				cwd,
+				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
+//#region src/commands/inertia-install.command.ts
+const ROOT_HTML = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  @viteHead
+  @inertiaHead
+</head>
+<body>
+  @inertia
+  @viteScripts
+</body>
+</html>`;
+const APP_TSX = `import { createInertiaApp } from '@inertiajs/react'
+
+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>
+      <h1>{message}</h1>
+      <p>This page is rendered with Inertia.js and Stratal.</p>
+    </div>
+  )
+}`;
+var InertiaInstallCommand = class extends Command {
+	static command = "inertia:install {--skip-deps : Skip installing npm dependencies}";
+	static description = "Scaffold Inertia.js files for a Stratal project";
+	async handle() {
+		const skipDeps = this.boolean("skip-deps");
+		const cwd = process.cwd();
+		const inertiaDir = join(cwd, "src", "inertia");
+		const pagesDir = join(inertiaDir, "pages");
+		this.info("Creating src/inertia/ directory...");
+		mkdirSync(pagesDir, { recursive: true });
+		const publicDir = join(inertiaDir, "public");
+		mkdirSync(publicDir, { recursive: true });
+		const gitkeepPath = join(publicDir, ".gitkeep");
+		if (!existsSync(gitkeepPath)) writeFileSync(gitkeepPath, "", "utf-8");
+		this.success("Created src/inertia/public/");
+		const files = [
+			{
+				path: join(inertiaDir, "root.html"),
+				content: ROOT_HTML,
+				name: "root.html"
+			},
+			{
+				path: join(inertiaDir, "app.tsx"),
+				content: APP_TSX,
+				name: "app.tsx"
+			},
+			{
+				path: join(pagesDir, "Home.tsx"),
+				content: HOME_TSX,
+				name: "pages/Home.tsx"
+			}
+		];
+		for (const file of files) if (existsSync(file.path)) this.warn(`Skipping ${file.name} (already exists)`);
+		else {
+			writeFileSync(file.path, file.content, "utf-8");
+			this.success(`Created src/inertia/${file.name}`);
+		}
+		const appModulePath = join(cwd, "src", "app.module.ts");
+		if (existsSync(appModulePath)) {
+			this.info("Updating src/app.module.ts...");
+			try {
+				if (await this.updateAppModule(appModulePath)) this.success("Updated src/app.module.ts with InertiaModule");
+				else this.info("InertiaModule already configured in app.module.ts");
+			} catch (err) {
+				this.warn(`Could not auto-update app.module.ts: ${err.message}`);
+				this.info("Please manually add InertiaModule.forRoot() to your module imports");
+			}
+		} else this.info("No src/app.module.ts found — please manually configure InertiaModule");
+		try {
+			const { outputPath, pageCount } = await runTypeGeneration(cwd);
+			const relPath = relative(cwd, outputPath);
+			this.success(`Generated ${relPath} (${pageCount} page${pageCount !== 1 ? "s" : ""})`);
+		} catch {
+			this.warn("Could not generate initial type definitions. Run `quarry inertia:types` manually.");
+		}
+		if (!skipDeps) {
+			this.newLine();
+			this.info("Install the following dependencies:");
+			this.line("  npm install @stratal/inertia @inertiajs/react @inertiajs/vite react react-dom");
+			this.line("  npm install -D @types/react @types/react-dom vite @cloudflare/vite-plugin");
+		}
+		this.newLine();
+		this.success("Inertia.js scaffolding complete!");
+		this.info("Run `quarry inertia:dev` to start the dev server");
+		return 0;
+	}
+	async updateAppModule(modulePath) {
+		const { Project, SyntaxKind } = await import("ts-morph");
+		const sourceFile = new Project({ useInMemoryFileSystem: false }).addSourceFileAtPath(modulePath);
+		if (sourceFile.getImportDeclaration((decl) => decl.getModuleSpecifierValue() === "@stratal/inertia")) return false;
+		sourceFile.addImportDeclaration({
+			defaultImport: "rootView",
+			moduleSpecifier: "./inertia/root.html?raw"
+		});
+		sourceFile.addImportDeclaration({
+			namedImports: ["InertiaModule"],
+			moduleSpecifier: "@stratal/inertia"
+		});
+		const classes = sourceFile.getClasses();
+		for (const cls of classes) {
+			const moduleDecorator = cls.getDecorator("Module");
+			if (!moduleDecorator) continue;
+			const args = moduleDecorator.getArguments();
+			if (args.length === 0) continue;
+			const objLiteral = args[0].asKind(SyntaxKind.ObjectLiteralExpression);
+			if (!objLiteral) continue;
+			const importsProp = objLiteral.getProperty("imports");
+			if (importsProp) {
+				const arrayLiteral = (importsProp.asKind(SyntaxKind.PropertyAssignment)?.getInitializer())?.asKind(SyntaxKind.ArrayLiteralExpression);
+				if (arrayLiteral) arrayLiteral.addElement(`InertiaModule.forRoot({\n    rootView,\n  })`);
+			} else objLiteral.addPropertyAssignment({
+				name: "imports",
+				initializer: `[\n    InertiaModule.forRoot({\n      rootView,\n    }),\n  ]`
+			});
+			break;
+		}
+		await sourceFile.save();
+		return true;
+	}
+};
+//#endregion
+//#region src/commands/inertia-types.command.ts
+var InertiaTypesCommand = class extends Command {
+	static command = "inertia:types {--watch : Watch for changes and regenerate}";
+	static description = "Generate Inertia.js page type definitions";
+	async handle() {
+		const cwd = process.cwd();
+		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);
+		}
+		return 0;
+	}
+	async generate(cwd) {
+		try {
+			const { outputPath, pageCount } = await runTypeGeneration(cwd);
+			const relPath = relative(cwd, outputPath);
+			this.success(`Generated ${relPath} (${pageCount} page${pageCount !== 1 ? "s" : ""})`);
+			return true;
+		} catch (err) {
+			this.fail(`Type generation failed: ${err.message}`);
+			return false;
+		}
+	}
+	async watchForChanges(cwd) {
+		const srcDir = join(cwd, "src");
+		try {
+			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);
+			}
+		} catch (err) {
+			this.fail(`Watch failed: ${err.message}`);
+		}
+	}
+};
+//#endregion
+//#region src/inertia.tokens.ts
+const INERTIA_TOKENS = {
+	Options: Symbol.for("stratal:inertia:options"),
+	InertiaService: Symbol.for("stratal:inertia:service"),
+	TemplateService: Symbol.for("stratal:inertia:template"),
+	ManifestService: Symbol.for("stratal:inertia:manifest"),
+	SsrRenderer: Symbol.for("stratal:inertia:ssr-renderer")
+};
+//#endregion
+//#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.127.0/helpers/decorateParam.js
+function __decorateParam(paramIndex, decorator) {
+	return function(target, key) {
+		decorator(target, key, paramIndex);
+	};
+}
+//#endregion
+//#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);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+//#endregion
+//#region src/middleware/inertia.middleware.ts
+let InertiaMiddleware = class InertiaMiddleware {
+	constructor(options) {
+		this.options = options;
+	}
+	async handle(ctx, next) {
+		const isInertia = ctx.header("x-inertia") === "true";
+		const isPrefetch = ctx.header("purpose") === "prefetch";
+		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 ?? "";
+			if (clientVersion && serverVersion && clientVersion !== serverVersion) {
+				ctx.c.header("X-Inertia-Location", ctx.c.req.url);
+				ctx.c.status(409);
+				return;
+			}
+		}
+		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;
+			if (ctx.c.res.status === 302 && method !== "GET" && method !== "HEAD") ctx.c.status(303);
+		}
+	}
+};
+InertiaMiddleware = __decorate([
+	Transient(),
+	__decorateParam(0, inject(INERTIA_TOKENS.Options)),
+	__decorateMetadata("design:paramtypes", [Object])
+], InertiaMiddleware);
+//#endregion
+//#region src/types.ts
+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 {
+	sharedData = {};
+	constructor(options, template, ssr) {
+		this.options = options;
+		this.template = template;
+		this.ssr = ssr;
+	}
+	share(key, value) {
+		this.sharedData[key] = value;
+	}
+	location(url) {
+		return new Response("", {
+			status: 409,
+			headers: { "X-Inertia-Location": url }
+		});
+	}
+	optional(callback) {
+		return {
+			[INERTIA_PROP_OPTIONAL]: true,
+			callback
+		};
+	}
+	defer(callback, group = "default") {
+		return {
+			[INERTIA_PROP_DEFERRED]: true,
+			callback,
+			group
+		};
+	}
+	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 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 = {
+			...resolvedShared,
+			...this.sharedData,
+			...props
+		};
+		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: {
+				...result.resolvedProps,
+				errors
+			},
+			url,
+			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.preserveFragment ? { preserveFragment: true } : {}
+		};
+		if (isInertia) return new Response(JSON.stringify(page), {
+			status: 200,
+			headers: {
+				"Content-Type": "application/json",
+				"X-Inertia": "true",
+				"Vary": "X-Inertia"
+			}
+		});
+		const ssrResult = ctx.c.get("withoutSsr") || this.isSsrDisabled(url) ? {
+			head: [],
+			body: ""
+		} : await this.ssr.render(page);
+		const html = this.template.render(page, ssrResult.head, ssrResult.body);
+		return new Response(html, {
+			status: 200,
+			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) for (const [key, value] of Object.entries(configShared)) if (typeof value === "function") shared[key] = await value(ctx);
+		else shared[key] = value;
+		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) {
+					deferredProps[value.group] ??= [];
+					deferredProps[value.group].push(key);
+				}
+				continue;
+			}
+			if (this.isMergeProp(value)) {
+				if (isPartialReload && !this.isRequested(key, requestedProps)) continue;
+				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;
+			}
+			if (this.isOptionalProp(value)) {
+				if (isPartialReload && this.isRequested(key, requestedProps)) resolvedProps[key] = await value.callback();
+				continue;
+			}
+			if (isPartialReload) {
+				if (this.isRequested(key, requestedProps) && !this.isExcepted(key, exceptProps)) resolvedProps[key] = value;
+			} else resolvedProps[key] = value;
+		}
+		return {
+			resolvedProps,
+			mergeProps,
+			prependProps,
+			deepMergeProps,
+			matchPropsOn,
+			deferredProps,
+			onceProps
+		};
+	}
+	/**
+	* Check if a prop key is requested — supports dot-notation (e.g., `user.permissions`
+	* matches the top-level `user` key).
+	*/
+	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;
+	}
+	isDeferredProp(value) {
+		return typeof value === "object" && value !== null && INERTIA_PROP_DEFERRED in value;
+	}
+	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;
+		return patterns.some((pattern) => {
+			const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+			return new RegExp(`^/${escaped.replace(/\*/g, "[^/]*")}$`).test(pathname);
+		});
+	}
+};
+InertiaService = __decorate([
+	Transient(INERTIA_TOKENS.InertiaService),
+	__decorateParam(0, inject(INERTIA_TOKENS.Options)),
+	__decorateParam(1, inject(INERTIA_TOKENS.TemplateService)),
+	__decorateParam(2, inject(INERTIA_TOKENS.SsrRenderer)),
+	__decorateMetadata("design:paramtypes", [
+		Object,
+		Object,
+		Object
+	])
+], InertiaService);
+//#endregion
+//#region src/services/manifest.service.ts
+const DEFAULT_ENTRY_CLIENT_PATH = "src/inertia/app.tsx";
+let ManifestService = class ManifestService {
+	manifest;
+	entryClientPath;
+	constructor(options) {
+		this.manifest = options.manifest ?? null;
+		this.entryClientPath = (options.entryClientPath ?? DEFAULT_ENTRY_CLIENT_PATH).replace(/^\/+/, "");
+	}
+	get isDev() {
+		return this.manifest === null;
+	}
+	getHeadTags() {
+		if (this.isDev) return "<link rel=\"stylesheet\" href=\"/__inertia/ssr-css\" data-ssr-css />";
+		const tags = [];
+		const seen = /* @__PURE__ */ new Set();
+		for (const entry of Object.values(this.manifest)) if (entry.css) for (const cssFile of entry.css) {
+			if (seen.has(cssFile)) continue;
+			seen.add(cssFile);
+			tags.push(`<link rel="stylesheet" href="/${cssFile}" />`);
+		}
+		return tags.join("\n");
+	}
+	getScriptTags() {
+		if (this.isDev) return [
+			"<script type=\"module\" src=\"/@vite/client\"><\/script>",
+			`<script type="module">
+import { createHotContext } from "/@vite/client";
+const hot = createHotContext("/__ssr_css");
+hot.on("vite:afterUpdate", () => {
+  document.querySelectorAll("[data-ssr-css]").forEach(el => el.remove());
+});
+<\/script>`,
+			`<script type="module" src="/${this.entryClientPath}"><\/script>`
+		].join("\n");
+		const tags = [];
+		for (const entry of Object.values(this.manifest)) if (entry.isEntry) tags.push(`<script type="module" src="/${entry.file}"><\/script>`);
+		return tags.join("\n");
+	}
+};
+ManifestService = __decorate([
+	Transient(),
+	__decorateParam(0, inject(INERTIA_TOKENS.Options)),
+	__decorateMetadata("design:paramtypes", [Object])
+], ManifestService);
+//#endregion
+//#region src/services/ssr-renderer.service.ts
+let SsrRendererService = class SsrRendererService {
+	bundle = null;
+	loadPromise = null;
+	constructor(options, logger) {
+		this.options = options;
+		this.logger = logger;
+	}
+	async render(page) {
+		if (!this.options.ssr) return {
+			head: [],
+			body: ""
+		};
+		await this.ensureBundle();
+		if (!this.bundle) return {
+			head: [],
+			body: ""
+		};
+		return this.bundle.render(page);
+	}
+	async ensureBundle() {
+		if (this.bundle) return;
+		this.loadPromise ??= this.loadBundle();
+		try {
+			await this.loadPromise;
+		} catch {}
+	}
+	async loadBundle() {
+		if (!this.options.ssr) return;
+		try {
+			const mod = await this.options.ssr.bundle();
+			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;
+		}
+	}
+};
+SsrRendererService = __decorate([
+	Transient(),
+	__decorateParam(0, inject(INERTIA_TOKENS.Options)),
+	__decorateParam(1, inject(LOGGER_TOKENS.LoggerService)),
+	__decorateMetadata("design:paramtypes", [Object, Object])
+], SsrRendererService);
+//#endregion
+//#region src/services/template.service.ts
+let TemplateService = class TemplateService {
+	constructor(options, manifest) {
+		this.options = options;
+		this.manifest = manifest;
+	}
+	render(page, ssrHead, ssrBody) {
+		const appHtml = ssrBody || this.buildClientOnlyBody(page);
+		const headTags = ssrHead.length > 0 ? ssrHead.join("\n") : "";
+		const viteHead = this.manifest.getHeadTags();
+		const viteScripts = this.manifest.getScriptTags();
+		let html = this.options.rootView;
+		html = html.replace("@inertiaHead", headTags);
+		html = html.replace("@inertia", appHtml);
+		html = html.replace("@viteHead", viteHead);
+		html = html.replace("@viteScripts", viteScripts);
+		return html;
+	}
+	buildClientOnlyBody(page) {
+		return `<script data-page="app" type="application/json">${JSON.stringify(page).replace(/\//g, "\\/")}<\/script><div id="app"></div>`;
+	}
+};
+TemplateService = __decorate([
+	Transient(),
+	__decorateParam(0, inject(INERTIA_TOKENS.Options)),
+	__decorateParam(1, inject(INERTIA_TOKENS.ManifestService)),
+	__decorateMetadata("design:paramtypes", [Object, Object])
+], TemplateService);
+//#endregion
+//#region src/inertia.module.ts
+var _InertiaModule;
+let InertiaModule = _InertiaModule = class InertiaModule {
+	static forRoot(options) {
+		return {
+			module: _InertiaModule,
+			providers: [{
+				provide: INERTIA_TOKENS.Options,
+				useValue: options
+			}]
+		};
+	}
+	static forRootAsync(options) {
+		return {
+			module: _InertiaModule,
+			providers: [{
+				provide: INERTIA_TOKENS.Options,
+				useFactory: options.useFactory,
+				inject: options.inject
+			}]
+		};
+	}
+	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,
+		scope: Scope.Request
+	},
+	{
+		provide: INERTIA_TOKENS.TemplateService,
+		useClass: TemplateService
+	},
+	{
+		provide: INERTIA_TOKENS.ManifestService,
+		useClass: ManifestService
+	},
+	{
+		provide: INERTIA_TOKENS.SsrRenderer,
+		useClass: SsrRendererService,
+		scope: Scope.Singleton
+	},
+	InertiaInstallCommand,
+	InertiaTypesCommand,
+	InertiaDevCommand,
+	InertiaBuildCommand
+] })], InertiaModule);
+//#endregion
+//#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"
+};
+/**
+* Builds a full RouteConfig from InertiaRouteConfig by applying inertia defaults.
+*/
+function buildInertiaConfig(config) {
+	const { hideFromDocs = true, ...rest } = config;
+	return {
+		...rest,
+		response: inertiaResponse,
+		hideFromDocs
+	};
+}
+/**
+* Decorator for Inertia page routes using convention-based routing.
+*
+* Wraps `@Route()` with:
+* - Auto-applied Inertia page response schema
+* - `hideFromDocs: true` by default (overridable)
+*
+* **Cannot be mixed with HTTP method decorators** (`@Get`, `@Post`, `@InertiaGet`, etc.)
+* in the same controller.
+*
+* @example
+* ```typescript
+* @Controller('/notes')
+* export class NotesController implements IController {
+*   @InertiaRoute({ query: z.object({ page: z.string().optional() }) })
+*   async index(ctx: RouterContext) {
+*     return ctx.inertia('notes/Index', { notes: [] })
+*   }
+* }
+* ```
+*/
+function InertiaRoute(config = {}) {
+	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 { 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