@stratal/inertia 0.0.27 → 0.1.1

package/dist/index.mjs

@@ -1,12 +1,13 @@
-import { t as __decorate } from "./decorate-B7nr7eBl.mjs";
+import { t as __decorate } from "./decorate-RQD1h28J.mjs";
+import { getSsrExcludeMatchers, isSsrExcluded } from "./services/ssr-exclusion.mjs";
 import { n as buildSeoTags, r as descriptorToHtml, t as DATA_SEO_ATTR } from "./build-seo-tags-DBsHKxX9.mjs";
 import { ApplicationError } from "stratal/errors";
 import { Module } from "stratal/module";
-import { Delete, Get, Patch, Post, Put, ROUTER_TOKENS, Route, RouterContext, SchemaValidationError, applyTrailingSlash, resolveTrailingSlash } from "stratal/router";
+import { Delete, Get, Patch, Post, Put, ROUTER_CONTEXT_KEYS, ROUTER_TOKENS, Route, RouterContext, SchemaValidationError, applyTrailingSlash, resolveTrailingSlash } from "stratal/router";
 import { CONTAINER_TOKEN, DI_TOKENS, Request, Singleton, Transient, inject } from "stratal/di";
-import { I18N_TOKENS } from "stratal/i18n";
+import { I18N_TOKENS, resolveDetectionForPath } from "stratal/i18n";
 import { deleteCookie, getSignedCookie, setSignedCookie } from "hono/cookie";
-import { z } from "stratal/validation";
+import { array, boolean, nullable, number, object, optional, record, string, unknown } from "zod/mini";
 //#region src/augment/router-context.ts
 function augmentRouterContext(resolveService) {
 	const originalRedirect = RouterContext.prototype.redirect;
@@ -29,6 +30,9 @@ function augmentRouterContext(resolveService) {
 	RouterContext.macro("merge", function(callback, options) {
 		return resolveService(this).merge(callback, options);
 	});
+	RouterContext.macro("scroll", function(callback, options) {
+		return resolveService(this).scroll(callback, options);
+	});
 	RouterContext.macro("once", function(callback, options) {
 		return resolveService(this).once(callback, options);
 	});
@@ -45,9 +49,6 @@ function augmentRouterContext(resolveService) {
 	RouterContext.macro("seo", function(data) {
 		resolveService(this).seo(data);
 	});
-	RouterContext.macro("withoutSsr", function() {
-		this.c.set("withoutSsr", true);
-	});
 }
 //#endregion
 //#region src/inertia.tokens.ts
@@ -57,11 +58,53 @@ const INERTIA_TOKENS = {
 	TemplateService: Symbol.for("stratal:inertia:template"),
 	ManifestService: Symbol.for("stratal:inertia:manifest"),
 	SsrRenderer: Symbol.for("stratal:inertia:ssr-renderer"),
+	DocumentRenderer: Symbol.for("stratal:inertia:document-renderer"),
 	HreflangService: Symbol.for("stratal:inertia:hreflang"),
 	SeoService: Symbol.for("stratal:inertia:seo")
 };
 //#endregion
-//#region \0@oxc-project+runtime@0.133.0/helpers/esm/decorateParam.js
+//#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_SCROLL = Symbol.for("stratal:inertia:prop:scroll");
+const INERTIA_PROP_ONCE = Symbol.for("stratal:inertia:prop:once");
+const INERTIA_PROP_ALWAYS = Symbol.for("stratal:inertia:prop:always");
+/**
+* Header the client sends on every infinite-scroll fetch to say which end of the
+* accumulated list the response should be joined to. Absent on the first render,
+* which is not a scroll fetch.
+*/
+const INERTIA_SCROLL_MERGE_INTENT_HEADER = "x-inertia-infinite-scroll-merge-intent";
+/**
+* Every request header an Inertia response body is a function of, beyond
+* `X-Inertia` itself. This is the set `partialRequestFor` reads to decide which
+* props to resolve, so two requests to one URL differing in any of them receive
+* different bodies.
+*
+* They are declared in `Vary` on EVERY Inertia response, not only on partial
+* reloads, and that is the load-bearing part: a cache matches a stored response
+* against the `Vary` IT was stored with. A full page response stored under
+* `Vary: X-Inertia` alone would be served to a partial reload, which sends the
+* same `X-Inertia: true` and would receive the whole page in place of the props
+* it asked for.
+*
+* `X-Inertia-Version` is deliberately absent. A mismatch answers 409, which is
+* never cached, and the asset version only moves with a deploy — which moves the
+* Worker version that Workers Caching already keys on, so a stale client cannot
+* reach an entry stored before it.
+*/
+const INERTIA_VARY_HEADERS = [
+	"X-Inertia",
+	"X-Inertia-Partial-Component",
+	"X-Inertia-Partial-Data",
+	"X-Inertia-Partial-Except",
+	"X-Inertia-Reset",
+	"X-Inertia-Resolve-Deferred",
+	INERTIA_SCROLL_MERGE_INTENT_HEADER
+];
+//#endregion
+//#region \0@oxc-project+runtime@0.150.0/helpers/esm/decorateParam.js
 function __decorateParam(paramIndex, decorator) {
 	return function(target, key) {
 		decorator(target, key, paramIndex);
@@ -79,7 +122,6 @@ let InertiaMiddleware = class InertiaMiddleware {
 		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) {
@@ -91,8 +133,13 @@ let InertiaMiddleware = class InertiaMiddleware {
 			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);
+				ctx.c.res = new Response(null, {
+					status: 409,
+					headers: {
+						"X-Inertia-Location": ctx.c.req.url,
+						"X-Inertia-Version": serverVersion
+					}
+				});
 				return;
 			}
 		}
@@ -104,7 +151,10 @@ let InertiaMiddleware = class InertiaMiddleware {
 		}
 		const status = ctx.c.res?.status;
 		if (typeof status !== "number" || status < 200 || status > 599) return;
-		ctx.c.header("Vary", "X-Inertia");
+		const declaredVary = (ctx.c.res.headers.get("Vary") ?? "").split(",").map((name) => name.trim()).filter(Boolean);
+		const seen = new Set(declaredVary.map((name) => name.toLowerCase()));
+		const missing = INERTIA_VARY_HEADERS.filter((name) => !seen.has(name.toLowerCase()));
+		ctx.c.header("Vary", [...missing, ...declaredVary].join(", "));
 		if (isInertia && status === 302) {
 			const method = ctx.c.req.method;
 			if (method !== "GET" && method !== "HEAD") ctx.c.status(303);
@@ -113,6 +163,45 @@ let InertiaMiddleware = class InertiaMiddleware {
 };
 InertiaMiddleware = __decorate([Transient(), __decorateParam(0, inject(INERTIA_TOKENS.Options))], InertiaMiddleware);
 //#endregion
+//#region src/services/document-renderer.service.ts
+let DocumentRendererService = class DocumentRendererService {
+	options;
+	ssr;
+	template;
+	ssrExcludeMatchers = getSsrExcludeMatchers();
+	constructor(options, ssr, template) {
+		this.options = options;
+		this.ssr = ssr;
+		this.template = template;
+	}
+	/**
+	* Render `page` to an HTML document Response. `extraHead` tags are appended to
+	* `<head>` — after the SSR-rendered Inertia `<Head>` when streaming, or as the
+	* only head tags in the client-only shell.
+	*/
+	async render(page, status = 200, extraHead = []) {
+		if (!this.options.ssr || isSsrExcluded(page.component, this.ssrExcludeMatchers)) {
+			const html = this.template.renderClientOnly(page, extraHead);
+			return new Response(html, {
+				status,
+				headers: { "Content-Type": "text/html; charset=utf-8" }
+			});
+		}
+		const { head, stream } = await this.ssr.render(page);
+		const body = this.template.renderStream(page, [...head, ...extraHead], stream);
+		return new Response(body, {
+			status,
+			headers: { "Content-Type": "text/html; charset=utf-8" }
+		});
+	}
+};
+DocumentRendererService = __decorate([
+	Singleton(),
+	__decorateParam(0, inject(INERTIA_TOKENS.Options)),
+	__decorateParam(1, inject(INERTIA_TOKENS.SsrRenderer)),
+	__decorateParam(2, inject(INERTIA_TOKENS.TemplateService))
+], DocumentRendererService);
+//#endregion
 //#region src/services/hreflang.service.ts
 let HreflangService = class HreflangService {
 	container;
@@ -127,8 +216,9 @@ let HreflangService = class HreflangService {
 		const defaultLocale = i18n.defaultLocale ?? "en";
 		const trailingSlash = this.container.resolve(DI_TOKENS.Application).config.trailingSlash ?? "ignore";
 		const localeUrl = this.container.resolve(ROUTER_TOKENS.LocaleUrlService);
-		if (localeUrl.pathEnabled) return this.buildPathLinks(currentUrl, locales, defaultLocale, localeUrl, trailingSlash);
-		if ((i18n.detection && "strategy" in i18n.detection ? i18n.detection.strategy : void 0) === "querystring") return this.buildQuerystringLinks(currentUrl, locales, defaultLocale, trailingSlash);
+		if (localeUrl.isPathLocalized(currentUrl.pathname)) return this.buildPathLinks(currentUrl, locales, defaultLocale, localeUrl, trailingSlash);
+		const detection = resolveDetectionForPath(i18n.detection, currentUrl.pathname);
+		if (detection.enabled && detection.strategy === "querystring") return this.buildQuerystringLinks(currentUrl, locales, defaultLocale, trailingSlash);
 		return [];
 	}
 	buildPathLinks(url, locales, defaultLocale, localeUrl, trailingSlash) {
@@ -167,24 +257,95 @@ let HreflangService = class HreflangService {
 };
 HreflangService = __decorate([Singleton(), __decorateParam(0, inject(CONTAINER_TOKEN))], HreflangService);
 //#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");
+//#region src/services/inertia-cache-signals.ts
+/**
+* Report the conditions that make an Inertia page unsafe to cache, and the
+* request headers a safe one must be keyed on.
+*
+* A `once()` prop is the subtle one: it is contractually sent a single time,
+* so replaying it from cache to every client breaks the guarantee the API makes.
+*
+* A partial reload is NOT among them. It is a deterministic function of the URL
+* and of `INERTIA_VARY_HEADERS`, so it caches correctly once keyed on those —
+* and refusing it outright made every deferred prop permanently uncacheable,
+* which on a page that defers its expensive work is the whole of the cost.
+*/
+function buildInertiaCacheSignals(input) {
+	return {
+		hasFlash: Object.keys(input.flash).length > 0,
+		isPartial: input.isPartial,
+		hasOnceProps: Object.keys(input.onceProps).length > 0,
+		varyHeaders: INERTIA_VARY_HEADERS
+	};
+}
+//#endregion
+//#region src/errors/unrecognized-scroll-shape.error.ts
+/**
+* Raised when `ctx.scroll()` is handed a value whose paging identifiers it
+* cannot derive: neither the offset shape `{ data, pagination: { page,
+* totalPages } }` nor the cursor shape `{ data, cursorName, cursor, nextCursor,
+* prevCursor }`.
+*
+* A **programming error**, and deliberately loud: guessing an identifier is
+* worse than failing, because a wrong `nextPage` reads to the client as "no
+* more pages" and silently truncates the list. No request recovers from it and
+* it carries no HTTP status. The fix is in the route — return one of the two
+* recognized shapes, or pass `metadata` to `ctx.scroll()` to extract
+* `pageName`, `currentPage`, `previousPage` and `nextPage` from this one.
+*/
+var UnrecognizedScrollShapeError = class extends ApplicationError {};
+//#endregion
+//#region src/services/scroll-metadata.ts
+function isOffsetPaginatedResult(value) {
+	if (typeof value !== "object" || value === null || !("pagination" in value)) return false;
+	const { pagination } = value;
+	if (typeof pagination !== "object" || pagination === null) return false;
+	const { page, totalPages } = pagination;
+	return Number.isInteger(page) && Number.isInteger(totalPages);
+}
+function isCursorPageShape(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const { cursorName, cursor, nextCursor, prevCursor } = value;
+	return typeof cursorName === "string" && (typeof cursor === "string" || cursor === null) && (typeof nextCursor === "string" || nextCursor === null) && (typeof prevCursor === "string" || prevCursor === null);
+}
+/**
+* Derives the infinite-scroll identifiers from a paginated result.
+*
+* Recognises both of the framework's own paginated shapes — the offset one
+* `paginatedResponseSchema` describes, and the cursor one `db.$cursor`
+* returns. Anything else throws rather than guessing: a wrong `nextPage` reads
+* to the client as "no more pages" and silently truncates a list, so an
+* unrecognised shape has to be named at the call site with
+* `ctx.scroll(..., { metadata })`.
+*/
+function deriveScrollMetadata(value) {
+	if (isOffsetPaginatedResult(value)) {
+		const { page, totalPages } = value.pagination;
+		return {
+			pageName: "page",
+			currentPage: page,
+			previousPage: page > 1 ? page - 1 : null,
+			nextPage: page < totalPages ? page + 1 : null
+		};
+	}
+	if (isCursorPageShape(value)) return {
+		pageName: value.cursorName,
+		currentPage: value.cursor ?? 1,
+		previousPage: value.prevCursor,
+		nextPage: value.nextCursor
+	};
+	throw new UnrecognizedScrollShapeError("[stratal:inertia] Cannot derive infinite-scroll metadata: the value is neither an offset-paginated result (`{ data, pagination: { page, totalPages } }`) nor a cursor-paginated one (`{ data, cursorName, cursor, nextCursor, prevCursor }`). Pass `metadata` to `ctx.scroll()` to extract `pageName`, `currentPage`, `previousPage` and `nextPage` from this shape yourself.");
+}
 //#endregion
 //#region src/services/inertia.service.ts
 let InertiaService = class InertiaService {
 	options;
-	template;
-	ssr;
+	documentRenderer;
 	seoService;
 	sharedData = {};
-	constructor(options, template, ssr, seoService) {
+	constructor(options, documentRenderer, seoService) {
 		this.options = options;
-		this.template = template;
-		this.ssr = ssr;
+		this.documentRenderer = documentRenderer;
 		this.seoService = seoService;
 	}
 	share(key, value) {
@@ -220,6 +381,16 @@ let InertiaService = class InertiaService {
 			matchOn: options?.matchOn
 		};
 	}
+	scroll(callback, options) {
+		return {
+			[INERTIA_PROP_SCROLL]: true,
+			callback,
+			wrapper: options?.wrapper ?? "data",
+			matchOn: options?.matchOn,
+			pageName: options?.pageName,
+			metadata: options?.metadata
+		};
+	}
 	once(callback, options) {
 		return {
 			[INERTIA_PROP_ONCE]: true,
@@ -237,7 +408,6 @@ let InertiaService = class InertiaService {
 	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 pathname = reqUrl.pathname;
 		const isInertia = ctx.c.get("inertia");
 		const { shared: resolvedShared, sharedKeys } = await this.resolveSharedData(ctx);
 		const resolvedSeo = await this.seoService.resolve(ctx);
@@ -252,9 +422,19 @@ let InertiaService = class InertiaService {
 			...Object.keys(this.sharedData),
 			"seo"
 		];
-		const result = await this.processProps(allProps, ctx, component, isInertia);
-		const { errors: flashErrors, ...flash } = ctx.c.get("inertiaFlash") ?? {};
+		const result = await this.processProps(allProps, this.partialRequestFor(ctx, component, isInertia));
+		const rawFlash = ctx.c.get("inertiaFlash") ?? {};
+		const { errors: flashErrors, ...flash } = rawFlash;
 		const errors = flashErrors && typeof flashErrors === "object" && !Array.isArray(flashErrors) ? flashErrors : {};
+		ctx.c.set(ROUTER_CONTEXT_KEYS.RESPONSE_PAYLOAD, {
+			...result.resolvedProps,
+			errors
+		});
+		ctx.c.set("inertiaCacheSignals", buildInertiaCacheSignals({
+			flash: rawFlash,
+			isPartial: this.isPartialReload(ctx, component),
+			onceProps: result.onceProps
+		}));
 		const page = {
 			component,
 			props: {
@@ -270,6 +450,7 @@ let InertiaService = class InertiaService {
 			...result.prependProps.length > 0 ? { prependProps: result.prependProps } : {},
 			...result.deepMergeProps.length > 0 ? { deepMergeProps: result.deepMergeProps } : {},
 			...result.matchPropsOn.length > 0 ? { matchPropsOn: result.matchPropsOn } : {},
+			...Object.keys(result.scrollProps).length > 0 ? { scrollProps: result.scrollProps } : {},
 			...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 } : {},
@@ -288,19 +469,7 @@ let InertiaService = class InertiaService {
 			}
 		});
 		const seoTags = this.seoService.tagsFor(resolvedSeo);
-		if (ctx.c.get("withoutSsr") || this.isSsrDisabled(pathname) || !this.options.ssr) {
-			const html = this.template.renderClientOnly(page, seoTags);
-			return new Response(html, {
-				status,
-				headers: { "Content-Type": "text/html; charset=utf-8" }
-			});
-		}
-		const { head, stream } = await this.ssr.render(page);
-		const body = this.template.renderStream(page, [...head, ...seoTags], stream);
-		return new Response(body, {
-			status,
-			headers: { "Content-Type": "text/html; charset=utf-8" }
-		});
+		return this.documentRenderer.render(page, status, seoTags);
 	}
 	/**
 	* Resolve shared data from module options and i18n configuration.
@@ -351,89 +520,172 @@ let InertiaService = class InertiaService {
 		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 = {};
+	/**
+	* Reads everything about the incoming request that changes how props resolve.
+	*
+	* Split out so a caller assembling its own page — a modal level, whose props
+	* sit under a path rather than at the page root — can resolve props with the
+	* same semantics while supplying its own notion of which ones were asked for.
+	*/
+	partialRequestFor(ctx, component, isInertia) {
 		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 shouldResolveDeferred = ctx.header("x-inertia-resolve-deferred") === "true";
-		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)) {
+		return {
+			isPartial: !!(isInertia && partialComponent === component && partialDataHeader),
+			requested: partialDataHeader?.split(",").map((s) => s.trim()) ?? [],
+			except: partialExceptHeader?.split(",").map((s) => s.trim()) ?? [],
+			reset: resetHeader?.split(",").map((s) => s.trim()) ?? [],
+			prependIntent: ctx.header(INERTIA_SCROLL_MERGE_INTENT_HEADER) === "prepend",
+			resolveDeferred: ctx.header("x-inertia-resolve-deferred") === "true"
+		};
+	}
+	/**
+	* Resolves a prop record with the helper semantics `render()` applies, for a
+	* caller that owns its own page assembly.
+	*
+	* The returned paths are relative to the record passed in; a caller whose
+	* props live under a page path re-anchors them before they reach the page
+	* object.
+	*/
+	async resolveProps(props, request) {
+		return this.processProps(props, request);
+	}
+	async processProps(allProps, request) {
+		const resolution = {
+			resolvedProps: {},
+			mergeProps: [],
+			prependProps: [],
+			deepMergeProps: [],
+			matchPropsOn: [],
+			scrollProps: {},
+			deferredProps: {},
+			onceProps: {}
+		};
+		await this.collectProps(allProps, request, resolution, resolution.resolvedProps, "", false);
+		return resolution;
+	}
+	/**
+	* Resolve one record of props into `into`, naming each by its full path.
+	*
+	* Recursive because the protocol addresses a nested prop by its dot path: `only: ['auth.user']`
+	* asks for one field of `auth`, not for the whole of it. Answering with all of `auth` is the
+	* payload the partial reload was sent to avoid.
+	*
+	* Three things make a prop survive a partial reload, mirroring Laravel's resolver: the request
+	* is not partial, its own path was asked for, or an ancestor of it resolved. The last is why a
+	* `defer()`/`optional()` prop comes back whole when a path inside it is asked for — nothing
+	* inside a callback's result can be narrowed without running the callback, so once it runs, all
+	* of it is included.
+	*
+	* Only plain objects are descended into. An array is a value: the client reads `items.0.name`
+	* as a path, but a partial reload asking for one element of a list it does not hold yet has
+	* nothing to merge that element into.
+	*/
+	async collectProps(props, request, resolution, into, parentPath, parentWasResolved) {
+		const { isPartial: isPartialReload, requested: requestedProps, except: exceptProps, reset: resetProps, prependIntent, resolveDeferred: shouldResolveDeferred } = request;
+		for (const [key, value] of Object.entries(props)) {
+			const path = parentPath === "" ? key : `${parentPath}.${key}`;
+			const named = !isPartialReload || parentWasResolved || this.isNamed(path, requestedProps);
+			const encloses = isPartialReload && this.enclosesNamed(path, requestedProps);
 			if (this.isAlwaysProp(value)) {
-				resolvedProps[key] = await value.callback();
+				into[key] = await value.callback();
 				continue;
 			}
 			if (this.isOnceProp(value)) {
-				if (isPartialReload && this.isRequested(key, requestedProps)) resolvedProps[key] = await value.callback();
+				if (isPartialReload && (named || encloses)) into[key] = await value.callback();
 				else if (!isPartialReload) {
-					resolvedProps[key] = await value.callback();
-					onceProps[key] = {
-						prop: value.key ?? key,
+					into[key] = await value.callback();
+					resolution.onceProps[path] = {
+						prop: value.key ?? path,
 						...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) if (shouldResolveDeferred) resolvedProps[key] = await value.callback();
-				else {
-					deferredProps[value.group] ??= [];
-					deferredProps[value.group].push(key);
+				if (isPartialReload && (named || encloses)) into[key] = await value.callback();
+				else if (!isPartialReload) {
+					if (shouldResolveDeferred) into[key] = await value.callback();
+					else {
+						resolution.deferredProps[value.group] ??= [];
+						resolution.deferredProps[value.group].push(path);
+					}
 				}
 				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 (isPartialReload && !named && !encloses) continue;
+				if (!resetProps.includes(path)) {
+					switch (value.strategy) {
+						case "prepend":
+							resolution.prependProps.push(path);
+							break;
+						case "deep":
+							resolution.deepMergeProps.push(path);
+							break;
+						default: resolution.mergeProps.push(path);
+					}
+					if (value.matchOn) resolution.matchPropsOn.push(`${path}.${value.matchOn}`);
+				}
+				into[key] = await value.callback();
+				continue;
+			}
+			if (this.isScrollProp(value)) {
+				if (isPartialReload && !named && !encloses) continue;
+				const resolved = await value.callback();
+				const isReset = resetProps.includes(path);
+				if (!isReset) {
+					const mergePath = `${path}.${value.wrapper}`;
+					if (prependIntent) resolution.prependProps.push(mergePath);
+					else resolution.mergeProps.push(mergePath);
+					if (value.matchOn) resolution.matchPropsOn.push(`${mergePath}.${value.matchOn}`);
 				}
-				if (value.matchOn) matchPropsOn.push(`${key}:${value.matchOn}`);
-				resolvedProps[key] = await value.callback();
+				const metadata = value.metadata ? value.metadata(resolved) : deriveScrollMetadata(resolved);
+				resolution.scrollProps[path] = {
+					pageName: value.pageName ?? metadata.pageName,
+					currentPage: metadata.currentPage,
+					previousPage: metadata.previousPage,
+					nextPage: metadata.nextPage,
+					reset: isReset
+				};
+				into[key] = resolved;
 				continue;
 			}
 			if (this.isOptionalProp(value)) {
-				if (isPartialReload && this.isRequested(key, requestedProps)) resolvedProps[key] = await value.callback();
+				if (isPartialReload && (named || encloses)) into[key] = await value.callback();
+				continue;
+			}
+			if (!named && encloses && this.isPlainRecord(value)) {
+				const child = {};
+				await this.collectProps(value, request, resolution, child, path, false);
+				if (Object.keys(child).length > 0) into[key] = child;
+				continue;
+			}
+			if (!named || this.isExcepted(path, exceptProps)) continue;
+			if (this.isPlainRecord(value)) {
+				const child = {};
+				await this.collectProps(value, request, resolution, child, path, true);
+				into[key] = child;
 				continue;
 			}
-			if (isPartialReload) {
-				if (this.isRequested(key, requestedProps) && !this.isExcepted(key, exceptProps)) resolvedProps[key] = value;
-			} else resolvedProps[key] = value;
+			into[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}.`));
+	/** Whether a plain `{}` record, as opposed to an array, a class instance or a prop marker. */
+	isPlainRecord(value) {
+		if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+		const prototype = Object.getPrototypeOf(value);
+		return prototype === Object.prototype || prototype === null;
+	}
+	/** Whether this path was asked for, or sits inside a path that was. */
+	isNamed(path, requestedProps) {
+		return requestedProps.some((prop) => prop === path || path.startsWith(`${prop}.`));
+	}
+	/** Whether something asked for sits inside this path. */
+	enclosesNamed(path, requestedProps) {
+		return requestedProps.some((prop) => prop.startsWith(`${path}.`));
 	}
 	isExcepted(key, exceptProps) {
 		return exceptProps.some((prop) => prop === key || prop.startsWith(`${key}.`));
@@ -447,6 +699,9 @@ let InertiaService = class InertiaService {
 	isMergeProp(value) {
 		return typeof value === "object" && value !== null && INERTIA_PROP_MERGE in value;
 	}
+	isScrollProp(value) {
+		return typeof value === "object" && value !== null && INERTIA_PROP_SCROLL in value;
+	}
 	isOnceProp(value) {
 		return typeof value === "object" && value !== null && INERTIA_PROP_ONCE in value;
 	}
@@ -464,21 +719,12 @@ let InertiaService = class InertiaService {
 		};
 		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([
 	Request(INERTIA_TOKENS.InertiaService),
 	__decorateParam(0, inject(INERTIA_TOKENS.Options)),
-	__decorateParam(1, inject(INERTIA_TOKENS.TemplateService)),
-	__decorateParam(2, inject(INERTIA_TOKENS.SsrRenderer)),
-	__decorateParam(3, inject(INERTIA_TOKENS.SeoService))
+	__decorateParam(1, inject(INERTIA_TOKENS.DocumentRenderer)),
+	__decorateParam(2, inject(INERTIA_TOKENS.SeoService))
 ], InertiaService);
 //#endregion
 //#region src/services/manifest.service.ts
@@ -544,6 +790,16 @@ let SeoService = class SeoService {
 		this.accumulated = mergeSeo(this.accumulated, data);
 	}
 	/**
+	* Whether anything has contributed SEO to this request.
+	*
+	* Told apart from "resolves to the defaults" so a caller rendering one page over another can
+	* keep the underlying page's metadata when the page on top named none of its own. Resolving
+	* regardless would answer with the module defaults and overwrite it.
+	*/
+	contributed() {
+		return Object.keys(this.accumulated).length > 0;
+	}
+	/**
 	* Resolves the final SEO data: module defaults (base) merged with the
 	* request's accumulated data, then the title template applied. Resolver
 	* functions for `defaults`/`titleTemplate` are awaited with the request `ctx`.
@@ -844,6 +1100,10 @@ InertiaModule = _InertiaModule = __decorate([Module({ providers: [
 		provide: INERTIA_TOKENS.SsrRenderer,
 		useClass: SsrRendererService
 	},
+	{
+		provide: INERTIA_TOKENS.DocumentRenderer,
+		useClass: DocumentRendererService
+	},
 	{
 		provide: INERTIA_TOKENS.HreflangService,
 		useClass: HreflangService
@@ -892,27 +1152,27 @@ var CookieFlashStore = class {
 	}
 };
 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()
+	schema: object({
+		component: string(),
+		props: record(string(), unknown()),
+		url: string(),
+		version: nullable(string()),
+		flash: record(string(), unknown()),
+		rememberedState: record(string(), unknown()),
+		mergeProps: optional(array(string())),
+		prependProps: optional(array(string())),
+		deepMergeProps: optional(array(string())),
+		matchPropsOn: optional(array(string())),
+		deferredProps: optional(record(string(), array(string()))),
+		initialDeferredProps: optional(record(string(), array(string()))),
+		onceProps: optional(record(string(), object({
+			prop: string(),
+			expiresAt: optional(nullable(number()))
+		}))),
+		sharedProps: optional(array(string())),
+		encryptHistory: optional(boolean()),
+		clearHistory: optional(boolean()),
+		preserveFragment: optional(boolean())
 	}),
 	description: "Inertia page response",
 	contentType: "text/html"
@@ -1047,6 +1307,6 @@ let HandlePrecognitiveRequests = class HandlePrecognitiveRequests {
 };
 HandlePrecognitiveRequests = __decorate([Transient()], HandlePrecognitiveRequests);
 //#endregion
-export { CookieFlashStore, DATA_SEO_ATTR, HandlePrecognitiveRequests, INERTIA_TOKENS, InertiaDelete, InertiaGet, InertiaMiddleware, InertiaModule, InertiaPatch, InertiaPost, InertiaPut, InertiaRoute, InertiaService, ManifestService, SeoService, SsrRendererService, TemplateService, buildSeoTags, descriptorToHtml };
+export { CookieFlashStore, DATA_SEO_ATTR, DocumentRendererService, HandlePrecognitiveRequests, INERTIA_SCROLL_MERGE_INTENT_HEADER, INERTIA_TOKENS, INERTIA_VARY_HEADERS, InertiaDelete, InertiaGet, InertiaMiddleware, InertiaModule, InertiaPatch, InertiaPost, InertiaPut, InertiaRoute, InertiaService, ManifestService, SeoService, SsrRendererService, TemplateService, UnrecognizedScrollShapeError, buildSeoTags, deriveScrollMetadata, descriptorToHtml };
 
 //# sourceMappingURL=index.mjs.map