@stratal/inertia 0.0.1

package/dist/index.mjs

@@ -0,0 +1,784 @@
+import { n as runTypeGeneration, t as findPagesDir } from "./type-generator-DlXIc6e2.mjs";
+import { Module } from "stratal/module";
+import { Route, RouterContext } from "stratal/router";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join, relative } from "node:path";
+import { Command } from "stratal/quarry";
+import { watch } from "node:fs/promises";
+import { Transient, inject } from "stratal/di";
+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) {
+		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) {
+		return resolveService(this).render(this, component, props, options);
+	};
+	proto.defer = function(callback, group) {
+		return resolveService(this).defer(callback, group);
+	};
+	proto.optional = function(callback) {
+		return resolveService(this).optional(callback);
+	};
+	proto.merge = function(callback) {
+		return resolveService(this).merge(callback);
+	};
+	proto.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);
+}
+//#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();
+		const entryPath = "src/inertia/app.tsx";
+		if (!existsSync(join(cwd, entryPath))) {
+			this.fail("src/inertia/app.tsx not found. Run `quarry inertia:install` first.");
+			return 1;
+		}
+		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!");
+			}
+			this.success(`Output in ${outDir}/`);
+		} catch (err) {
+			this.fail(`Build failed: ${err.message}`);
+			return 1;
+		}
+		return 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 description = "Start Inertia.js Vite development server";
+	async handle() {
+		const port = this.number("port") || 5173;
+		const host = this.boolean("host");
+		const cwd = process.cwd();
+		const entryPath = "src/inertia/app.tsx";
+		if (!existsSync(join(cwd, entryPath))) {
+			this.fail("src/inertia/app.tsx not found. Run `quarry inertia:install` first.");
+			return 1;
+		}
+		this.info("Starting Vite dev server...");
+		try {
+			const { createServer } = await import("vite");
+			const server = await createServer(await createInertiaViteConfig({
+				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;
+	}
+};
+//#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()`;
+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();
+		const pagesDir = findPagesDir(cwd);
+		if (!existsSync(pagesDir)) {
+			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);
+		}
+		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, pagesDir) {
+		try {
+			const watcher = watch(pagesDir, { 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.115.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
+function __decorateParam(paramIndex, decorator) {
+	return function(target, key) {
+		decorator(target, key, paramIndex);
+	};
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.115.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);
+		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();
+		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");
+//#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) {
+		return {
+			[INERTIA_PROP_MERGE]: true,
+			callback
+		};
+	}
+	async render(ctx, component, props = {}, renderOptions = {}) {
+		const url = new URL(ctx.c.req.url).pathname;
+		const isInertia = ctx.c.get("inertia");
+		const allProps = {
+			...await this.resolveSharedData(ctx),
+			...this.sharedData,
+			...props
+		};
+		const { resolvedProps, mergeProps, deferredProps } = await this.processProps(allProps, ctx, component, isInertia);
+		const page = {
+			component,
+			props: resolvedProps,
+			url,
+			version: this.options.version ?? "",
+			mergeProps,
+			deferredProps,
+			...renderOptions.encryptHistory ? { encryptHistory: true } : {},
+			...renderOptions.clearHistory ? { clearHistory: 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" }
+		});
+	}
+	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);
+		else shared[key] = value;
+		return shared;
+	}
+	async processProps(allProps, ctx, component, isInertia) {
+		const resolvedProps = {};
+		const mergeProps = [];
+		const deferredProps = {};
+		const partialComponent = ctx.header("x-inertia-partial-component");
+		const partialDataHeader = ctx.header("x-inertia-partial-data");
+		const isPartialReload = isInertia && partialComponent === component && partialDataHeader;
+		const requestedProps = partialDataHeader?.split(",").map((s) => s.trim()) ?? [];
+		for (const [key, value] of Object.entries(allProps)) {
+			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;
+				mergeProps.push(key);
+				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)) resolvedProps[key] = value;
+			} else resolvedProps[key] = value;
+		}
+		return {
+			resolvedProps,
+			mergeProps,
+			deferredProps
+		};
+	}
+	/**
+	* 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}.`));
+	}
+	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;
+	}
+	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(),
+	__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) {
+		this.options = options;
+	}
+	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();
+			this.bundle = "default" in mod ? mod.default : mod;
+		} catch {
+			this.loadPromise = null;
+		}
+	}
+};
+SsrRendererService = __decorate([
+	Transient(),
+	__decorateParam(0, inject(INERTIA_TOKENS.Options)),
+	__decorateMetadata("design:paramtypes", [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
+			}]
+		};
+	}
+	configure(consumer) {
+		consumer.apply(InertiaMiddleware).forRoutes("*");
+	}
+	onInitialize() {
+		augmentRouterContext((ctx) => {
+			return ctx.getContainer().resolve(INERTIA_TOKENS.InertiaService);
+		});
+	}
+};
+InertiaModule = _InertiaModule = __decorate([Module({ providers: [
+	{
+		provide: INERTIA_TOKENS.InertiaService,
+		useClass: InertiaService
+	},
+	{
+		provide: INERTIA_TOKENS.TemplateService,
+		useClass: TemplateService
+	},
+	{
+		provide: INERTIA_TOKENS.ManifestService,
+		useClass: ManifestService
+	},
+	{
+		provide: INERTIA_TOKENS.SsrRenderer,
+		useClass: SsrRendererService
+	},
+	InertiaInstallCommand,
+	InertiaTypesCommand,
+	InertiaDevCommand,
+	InertiaBuildCommand
+] })], InertiaModule);
+//#endregion
+//#region src/decorators/inertia-route.decorator.ts
+/**
+* Zod schema for the Inertia page JSON response (returned for X-Inertia XHR requests)
+*/
+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()
+});
+/**
+* Decorator for Inertia page routes.
+*
+* Wraps `@Route()` with:
+* - Auto-applied Inertia page response schema
+* - `hideFromDocs: true` by default (overridable)
+*
+* Accepts `query`, `params`, `body`, `tags`, `summary`, `description`, `security`.
+*
+* @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 = {}) {
+	const { hideFromDocs = true, ...rest } = config;
+	return Route({
+		...rest,
+		response: {
+			schema: inertiaPageSchema,
+			description: "Inertia page response",
+			contentType: "text/html"
+		},
+		hideFromDocs
+	});
+}
+//#endregion
+export { INERTIA_TOKENS, InertiaBuildCommand, InertiaDevCommand, InertiaInstallCommand, InertiaMiddleware, InertiaModule, InertiaRoute, InertiaService, InertiaTypesCommand, ManifestService, SsrRendererService, TemplateService, runTypeGeneration };
+
+//# sourceMappingURL=index.mjs.map