@adonisjs/inertia 5.0.0-next.0 → 5.0.0-next.1

package/build/inertia_manager-BeqpMsuN.js

@@ -0,0 +1,1770 @@
+import { t as InertiaHeaders } from "./headers-B-5pLwyD.js";
+import { t as debug_default } from "./debug-Ca0ekg3M.js";
+import { createHash } from "node:crypto";
+import string from "@poppinss/utils/string";
+import { BaseSerializer } from "@adonisjs/core/transformers";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/symbols.ts
+var symbols_exports = /* @__PURE__ */ __exportAll({
+	ALWAYS_PROP: () => ALWAYS_PROP,
+	DEEP_MERGE: () => DEEP_MERGE,
+	DEFERRED_PROP: () => DEFERRED_PROP,
+	MERGE_MATCH_ON: () => MERGE_MATCH_ON,
+	MERGE_PREPEND: () => MERGE_PREPEND,
+	ONCE_PROP: () => ONCE_PROP,
+	OPTIONAL_PROP: () => OPTIONAL_PROP,
+	SCROLL_DEFERRED: () => SCROLL_DEFERRED,
+	SCROLL_PROP: () => SCROLL_PROP,
+	TO_BE_MERGED: () => TO_BE_MERGED
+});
+/**
+* Symbol used to mark props that should always be included in responses.
+* Props marked with this symbol cannot be filtered out during cherry-picking.
+*/
+const ALWAYS_PROP = Symbol.for("ALWAYS_PROP");
+/**
+* Symbol used to mark props that are optional and only included when explicitly requested.
+* These props are never included in standard visits and must be cherry-picked.
+*/
+const OPTIONAL_PROP = Symbol.for("OPTIONAL_PROP");
+/**
+* Symbol used to mark props that should be merged with existing props on the client.
+* Props marked with this symbol will be merged rather than replaced during updates.
+*/
+const TO_BE_MERGED = Symbol.for("TO_BE_MERGED");
+/**
+* Symbol used to mark props that are deferred and computed lazily.
+* These props are skipped in standard visits but communicated to the client for potential loading.
+*/
+const DEFERRED_PROP = Symbol.for("DEFERRED_PROP");
+/**
+* Symbol used to indicate that a mergeable prop should use deep merging behavior.
+* Deep merging recursively merges nested objects and arrays.
+*/
+const DEEP_MERGE = Symbol.for("DEEP_MERGE");
+/**
+* Symbol carrying the direction of a shallow array merge. When `true` the client
+* prepends the incoming items (`prependProps`); when `false` it appends them
+* (`mergeProps`). Ignored for deep merges — the client deep-merge path has no
+* direction.
+*/
+const MERGE_PREPEND = Symbol.for("MERGE_PREPEND");
+/**
+* Symbol carrying the match path (relative to the prop) used for keyed merges.
+* When set, the client dedupes/replaces array items by this field rather than
+* concatenating. Emitted on the wire as `"<propPath>.<matchOn>"` in `matchPropsOn`.
+*/
+const MERGE_MATCH_ON = Symbol.for("MERGE_MATCH_ON");
+/**
+* Symbol used to mark props that are remembered by the client across visits.
+* The server skips re-resolving a once prop when the client reports it already
+* holds the value, and always emits the prop's caching metadata.
+*/
+const ONCE_PROP = Symbol.for("ONCE_PROP");
+/**
+* Symbol used to mark an infinite-scroll prop. Scroll props layer pagination
+* metadata (emitted under the page object's `scrollProps`) on top of the keyed
+* and directional merge primitive, so the client can continuously load pages as
+* the user scrolls.
+*/
+const SCROLL_PROP = Symbol.for("SCROLL_PROP");
+/**
+* Type-only discriminant carrying whether a scroll prop has been deferred via
+* `.deferred()`. A deferred scroll prop is absent on the initial load, so this
+* flag lets the type system treat it as optional — rejecting it on a required
+* client prop, exactly like `defer()`. It is never set at runtime.
+*/
+const SCROLL_DEFERRED = Symbol.for("SCROLL_DEFERRED");
+//#endregion
+//#region src/props.ts
+var InertiaSerializer = class extends BaseSerializer {
+	wrap = void 0;
+	definePaginationMetaData(metaData) {
+		return metaData;
+	}
+};
+const inertiaSerializer = new InertiaSerializer();
+/**
+* Type guard to check if a value is a plain object
+*
+* @param value - The value to check
+* @returns True if the value is a plain object (not null, not array)
+*/
+function isObject(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/**
+* Creates a deferred prop that is never included in standard visits but must be shared with
+* the client during standard visits. Can be explicitly requested and supports merging.
+*
+* Deferred props are useful for expensive computations that should only be loaded when
+* specifically requested by the client.
+*
+* @param fn - Function that computes the prop value when requested
+* @param options - A group name string, or `{ group, rescue }`. Pass
+*   `{ rescue: true }` to catch resolution errors, omit the prop, and report its
+*   path via `rescuedProps` so the client can render the `<Deferred>` rescue slot.
+* @returns A deferred prop object with compute and merge capabilities
+*
+* @example
+* ```javascript
+* // Create a deferred prop for expensive user statistics
+* const userStats = defer(() => {
+*   return calculateExpensiveUserStats(userId)
+* })
+*
+* // Use in page props
+* return inertia.render('dashboard', {
+*   user: user,
+*   stats: userStats // Only loaded when explicitly requested
+* })
+*
+* // Rescue resolution failures instead of erroring the whole reload
+* const permissions = defer(() => Permission.all(), { rescue: true })
+* ```
+*/
+function defer(fn, groupOrOptions = {}) {
+	const { group = "default", rescue = false } = typeof groupOrOptions === "string" ? { group: groupOrOptions } : groupOrOptions;
+	return {
+		group,
+		rescue,
+		compute: fn,
+		merge() {
+			return merge(this);
+		},
+		deepMerge() {
+			return deepMerge(this);
+		},
+		once(options) {
+			return once(this, options);
+		},
+		[DEFERRED_PROP]: true
+	};
+}
+/**
+* Creates an optional prop that is never included in standard visits and can only be
+* explicitly requested by the client. Unlike deferred props, optional props are not
+* shared with the client during standard visits.
+*
+* Optional props are ideal for data that is rarely needed and should only be loaded
+* on demand to optimize performance.
+*
+* @param fn - Function that computes the prop value when requested
+* @returns An optional prop object that computes values lazily
+*
+* @example
+* ```javascript
+* // Create an optional prop for detailed audit logs
+* const auditLogs = optional(() => {
+*   return fetchDetailedAuditLogs(resourceId)
+* })
+*
+* // Use in page props
+* return inertia.render('resource/show', {
+*   resource: resource,
+*   auditLogs: auditLogs // Only loaded when explicitly requested
+* })
+* ```
+*/
+function optional(fn) {
+	return {
+		compute: fn,
+		once(options) {
+			return once(this, options);
+		},
+		[OPTIONAL_PROP]: true
+	};
+}
+/**
+* Creates a prop that is always included in responses and cannot be removed during
+* cherry-picking. This ensures the prop is always available to the frontend component.
+*
+* Always props are useful for critical data that the frontend component must have
+* to function properly, regardless of what props are specifically requested.
+*
+* @param value - The value to always include in the response
+* @returns An always prop object that cannot be cherry-picked away
+*
+* @example
+* ```javascript
+* // Create an always prop for critical user permissions
+* const userPermissions = always(user.permissions)
+*
+* // Use in page props
+* return inertia.render('admin/dashboard', {
+*   users: users,
+*   permissions: userPermissions // Always included, never filtered out
+* })
+* ```
+*/
+function always(value) {
+	return {
+		value,
+		[ALWAYS_PROP]: true
+	};
+}
+/**
+* Creates a prop that should be merged with existing props on the page rather than
+* replaced. This is useful for incremental updates where you want to combine new
+* data with existing data on the client side.
+*
+* Mergeable props enable efficient partial updates by allowing the client to
+* merge new prop values with existing ones instead of replacing them entirely.
+*
+* @param value - The value to be merged with existing props
+* @returns A mergeable prop object marked for merging behavior
+*
+* @example
+* ```javascript
+* // Create a mergeable prop for incremental notifications
+* const newNotifications = merge([
+*   { id: 1, message: 'New message received' },
+*   { id: 2, message: 'Task completed' }
+* ])
+*
+* // Use in page props - will merge with existing notifications
+* return inertia.render('dashboard', {
+*   user: user,
+*   notifications: newNotifications // Merges with existing notifications array
+* })
+* ```
+*/
+function merge(value) {
+	return createMergeableProp(value, false);
+}
+/**
+* Builds a mergeable prop wrapper shared by `merge` and `deepMerge`. The chainable
+* `prepend`/`append`/`matchOn` methods mutate the wrapper's symbol-keyed config in
+* place and return it, so they compose fluently (e.g. `merge(v).prepend().matchOn('id')`).
+*
+* @param value - The value (or inner prop wrapper) to be merged
+* @param deep - Whether the merge is deep (recursive) rather than a shallow array merge
+* @returns A mergeable prop wrapper carrying merge metadata
+*/
+function createMergeableProp(value, deep) {
+	return {
+		value,
+		prepend() {
+			this[MERGE_PREPEND] = true;
+			return this;
+		},
+		append() {
+			this[MERGE_PREPEND] = false;
+			return this;
+		},
+		matchOn(key) {
+			this[MERGE_MATCH_ON] = key;
+			return this;
+		},
+		once(options) {
+			return once(this, options);
+		},
+		[TO_BE_MERGED]: true,
+		[DEEP_MERGE]: deep,
+		[MERGE_PREPEND]: false,
+		[MERGE_MATCH_ON]: void 0
+	};
+}
+/**
+* Detects an `@adonisjs/core` transformer paginator (the result of
+* `Transformer.paginate()`) via its `$type` discriminator. Its `metaData` is the
+* free-form object passed to `.paginate()` — by convention an AdonisJS Lucid
+* paginator's `getMeta()` output.
+*
+* @param value - The value to test
+* @returns True when the value is a transformer paginator
+*/
+function isTransformerPaginator(value) {
+	return value !== null && typeof value === "object" && value.$type === "paginator" && isObject(value.metaData);
+}
+/**
+* Extracts the infinite-scroll cursor from a transformer paginator's `metaData`,
+* mirroring `inertia-laravel`'s `ScrollMetadata::fromPaginator` for offset
+* paginators: the page identifiers are the adjacent page numbers (or `null` at
+* the boundaries), and `pageName` comes straight from the paginator meta.
+*
+* @param metaData - The paginator's metadata (Lucid `getMeta()` shape)
+* @returns The extracted cursor, or `null` when the metadata is not derivable
+*/
+function extractScrollPropsFromPaginatorMetaData(metaData) {
+	const currentPage = metaData.currentPage;
+	if (typeof currentPage !== "number") return null;
+	const lastPage = typeof metaData.lastPage === "number" ? metaData.lastPage : currentPage;
+	const firstPage = typeof metaData.firstPage === "number" ? metaData.firstPage : 1;
+	return {
+		pageName: typeof metaData.pageName === "string" ? metaData.pageName : "page",
+		currentPage,
+		nextPage: currentPage < lastPage ? currentPage + 1 : null,
+		previousPage: currentPage > firstPage ? currentPage - 1 : null
+	};
+}
+/**
+* The default scroll-props provider used when `scroll()` is called without one.
+* Auto-derives the cursor from a transformer paginator's offset metadata and
+* throws when no cursor can be derived (non-paginator values, or cursor
+* paginators) — so a scroll prop over a custom source fails loudly unless an
+* explicit provider is supplied.
+*
+* @param value - The resolved scroll prop value
+* @returns The pagination cursor extracted from the paginator
+*/
+function paginatorScrollPropsProvider(value) {
+	if (isTransformerPaginator(value)) {
+		const cursor = extractScrollPropsFromPaginatorMetaData(value.metaData);
+		if (cursor !== null) return cursor;
+	}
+	/**
+	* Reached when the value is not a transformer paginator, or is one whose
+	* metadata is not offset-paginated (e.g. a cursor paginator). Both need an
+	* explicit provider, so the message stays accurate for either case.
+	*/
+	throw new Error("Cannot derive an infinite-scroll cursor from the value. Pass a scrollProps callback as the second argument to \"scroll()\" for cursor or non-paginator sources.");
+}
+/**
+* Computes the wire labels for a scroll prop's merge: the dotted `data`-array
+* path the client merges directionally, and the optional keyed-match entry. The
+* client splits each entry on its last dot, so `"<key>.data"` resolves to the
+* `data` array under the prop and `"<key>.data.<matchOn>"` keys it.
+*
+* @param key - The prop's top-level path
+* @param scrollProp - The scroll prop wrapper carrying the match key
+* @returns The merge path and the optional `matchPropsOn` entry
+*/
+function scrollMergeLabels(key, scrollProp) {
+	const mergePath = `${key}.data`;
+	const matchOn = scrollProp[MERGE_MATCH_ON];
+	return {
+		mergePath,
+		matchEntry: matchOn === void 0 ? void 0 : `${mergePath}.${matchOn}`
+	};
+}
+/**
+* Creates a prop that should be deeply merged with existing props on the page.
+*
+* Unlike shallow merge, deep merge recursively merges nested objects and arrays,
+* allowing for more granular updates to complex data structures.
+*
+* @param value - The value to be deeply merged with existing props
+* @returns A mergeable prop object marked for deep merging behavior
+*
+* @example
+* ```javascript
+* // Create a deep mergeable prop for nested user settings
+* const updatedSettings = deepMerge({
+*   notifications: {
+*     email: true,
+*     push: false
+*   },
+*   privacy: {
+*     profile: 'public'
+*   }
+* })
+*
+* // Use in page props - will deeply merge with existing settings
+* return inertia.render('settings', {
+*   user: user,
+*   settings: updatedSettings // Deep merges with existing settings object
+* })
+* ```
+*/
+function deepMerge(value) {
+	return createMergeableProp(value, true);
+}
+/**
+* Creates a once prop: a prop the server computes, the client caches across
+* visits, and the server skips re-resolving on later visits where the client
+* reports it already holds a fresh value.
+*
+* Use the `.once()` chaining method to compose with `defer`/`optional`/`merge`;
+* use this standalone form for plain values and lazy callbacks.
+*
+* @param inner - The value, callback, or inner prop wrapper to remember
+* @param options - Custom key, expiry, and force-fresh options
+* @returns A once prop wrapper carrying caching metadata
+*
+* @example
+* ```js
+* // Plain value, no expiry
+* return inertia.render('dashboard', {
+*   lookups: inertia.once(() => loadLookupTables())
+* })
+*
+* // Custom key + expiry, composed with a deferred prop
+* return inertia.render('dashboard', {
+*   stats: inertia.defer(() => heavyStats()).once({ key: 'stats', expiresIn: '1h' })
+* })
+* ```
+*/
+function once(value, options = {}) {
+	return {
+		value,
+		onceKey: options.key,
+		expiry: {
+			expiresIn: options.expiresIn,
+			expiresAt: options.expiresAt
+		},
+		fresh: options.fresh ?? false,
+		[ONCE_PROP]: true
+	};
+}
+/**
+* Creates an infinite-scroll prop: a mergeable, paginated value the client keeps
+* extending as the user scrolls. The server labels the value's `data` array for
+* keyed/directional merging (driven by the client's merge-intent header) and
+* emits a pagination cursor under the page object's `scrollProps`.
+*
+* The value is a transformer paginator (cursor auto-derived from its metadata)
+* or any `{ data, ... }`-shaped value, given directly or via a callback. For a
+* non-paginator value, pass a `scrollProps` provider that computes the cursor
+* from the resolved value. Chain `.deferred()` to skip the first page on the
+* initial load, and `.matchOn()` to dedupe overlapping pages by a key.
+*
+* @param value - A transformer paginator or `{ data }` value (or a callback resolving to one)
+* @param provider - Computes the cursor from the resolved value; omit for transformer paginators
+* @returns A scroll prop wrapper carrying merge + pagination metadata
+*
+* @example
+* ```js
+* // Transformer paginator — cursor auto-derived from its metadata
+* return inertia.render('users/index', {
+*   users: inertia.scroll(() => UserTransformer.paginate(rows, paginator.getMeta()))
+* })
+*
+* // Custom / cursor source — cursor computed by a provider
+* return inertia.render('feed', {
+*   posts: inertia.scroll(() => feed, (value) => ({
+*     pageName: 'cursor',
+*     currentPage: value.cursor,
+*     nextPage: value.next,
+*     previousPage: null,
+*   }))
+* })
+* ```
+*/
+function scroll(value, provider) {
+	return {
+		value,
+		provider: provider ?? paginatorScrollPropsProvider,
+		deferred(group = "default") {
+			this.group = group;
+			/**
+			* The deferred flag is type-only (`[SCROLL_DEFERRED]`), so the runtime
+			* object is unchanged; the cast re-tags it as the deferred variant so it
+			* type-checks as optional on the client.
+			*/
+			return this;
+		},
+		matchOn(key) {
+			this[MERGE_MATCH_ON] = key;
+			return this;
+		},
+		[SCROLL_PROP]: true,
+		[MERGE_MATCH_ON]: void 0
+	};
+}
+/**
+* Type guard that checks if a prop value is a scroll prop.
+*
+* @param propValue - The object to check for scroll prop characteristics
+* @returns True if the prop value is a scroll prop
+*/
+function isScrollProp(propValue) {
+	return SCROLL_PROP in propValue;
+}
+/**
+* Type guard that checks if a prop value is a once prop.
+*
+* @param propValue - The object to check for once prop characteristics
+* @returns True if the prop value is a once prop
+*/
+function isOnceProp(propValue) {
+	return ONCE_PROP in propValue;
+}
+/**
+* Type guard that checks if a prop value is a deferred prop.
+*
+* Deferred props contain the DEFERRED_PROP symbol and have compute/merge capabilities.
+* This function is useful for runtime type checking and conditional prop handling.
+*
+* @param propValue - The object to check for deferred prop characteristics
+* @returns True if the prop value is a deferred prop
+*
+* @example
+* ```js
+* const prop = defer(() => ({ data: 'value' }))
+*
+* if (isDeferredProp(prop)) {
+*   // prop is now typed as DeferProp<T>
+*   const result = prop.compute()
+* }
+* ```
+*/
+function isDeferredProp(propValue) {
+	return DEFERRED_PROP in propValue;
+}
+/**
+* Type guard that checks if a prop value is a mergeable prop.
+*
+* Mergeable props contain the TO_BE_MERGED symbol and should be merged with
+* existing props rather than replaced during updates.
+*
+* @param propValue - The object to check for mergeable prop characteristics
+* @returns True if the prop value is a mergeable prop
+*
+* @example
+* ```js
+* const prop = merge({ items: [1, 2, 3] })
+*
+* if (isMergeableProp(prop)) {
+*   // prop is now typed as MergeableProp<T>
+*   const value = prop.value
+* }
+* ```
+*/
+function isMergeableProp(propValue) {
+	return TO_BE_MERGED in propValue;
+}
+/**
+* Type guard that checks if a prop value is an always prop.
+*
+* Always props contain the ALWAYS_PROP symbol and are always included in
+* responses, regardless of cherry-picking or selective prop requests.
+*
+* @param propValue - The object to check for always prop characteristics
+* @returns True if the prop value is an always prop
+*
+* @example
+* ```js
+* const prop = always({ userId: 123, permissions: ['read', 'write'] })
+*
+* if (isAlwaysProp(prop)) {
+*   // prop is now typed as AlwaysProp<T>
+*   const value = prop.value
+* }
+* ```
+*/
+function isAlwaysProp(propValue) {
+	return ALWAYS_PROP in propValue;
+}
+/**
+* Type guard that checks if a prop value is an optional prop.
+*
+* Optional props contain the OPTIONAL_PROP symbol and are only included
+* when explicitly requested by the client, never in standard visits.
+*
+* @param propValue - The object to check for optional prop characteristics
+* @returns True if the prop value is an optional prop
+*
+* @example
+* ```js
+* const prop = optional(() => ({ detailedData: 'expensive computation' }))
+*
+* if (isOptionalProp(prop)) {
+*   // prop is now typed as OptionalProp<T>
+*   const result = prop.compute()
+* }
+* ```
+*/
+function isOptionalProp(propValue) {
+	return OPTIONAL_PROP in propValue;
+}
+/**
+* Helper function to unpack prop values using the transformer serialize function.
+*
+* @param value - The prop value to serialize
+* @param containerResolver - Container resolver for dependency injection
+* @returns Promise resolving to the serialized JSON data
+*/
+async function unpackPropValue(value, containerResolver) {
+	if (value === null) return null;
+	return inertiaSerializer.serialize(value, containerResolver);
+}
+/**
+* Builds props for standard (non-partial) Inertia visits.
+*
+* This function processes page props and categorizes them based on their type:
+* - Deferred props: Skipped but communicated to client
+* - Optional props: Skipped entirely
+* - Always props: Always included
+* - Mergeable props: Included and marked for merging
+* - Regular props: Included normally
+*
+* @param pageProps - The page props to process
+* @param containerResolver - Container resolver for dependency injection
+* @returns Promise resolving to object containing processed props, deferred props list, and merge props list
+*
+* @example
+* ```js
+* const result = await buildStandardVisitProps({
+*   user: { name: 'John' },
+*   posts: defer(() => getPosts()),
+*   settings: merge({ theme: 'dark' })
+* })
+* // Returns: { props: { user: {...} }, deferredProps: { default: ['posts'] }, mergeProps: ['settings'] }
+* ```
+*/
+/**
+* Records a once prop's caching metadata and returns its resolved once-key. The
+* entry is emitted regardless of whether the value is ultimately sent, so the
+* client can keep using its cached copy.
+*
+* @param onceProps - The accumulator to record the metadata into
+* @param key - The prop's top-level path inside the props bag
+* @param prop - The once prop wrapper
+* @param now - Reference timestamp (epoch-ms) used to normalize relative expiry
+* @returns The once-key the entry was recorded under
+*/
+function emitOnceMetadata(onceProps, key, prop, now) {
+	const onceKey = prop.onceKey ?? key;
+	if (onceKey in onceProps) debug_default("duplicate once-key \"%s\" in a single response; last value wins", onceKey);
+	/**
+	* Normalize the expiry to absolute epoch-ms: an absolute `expiresAt` wins over
+	* a relative `expiresIn` (resolved against the response-build `now`); `null`
+	* when no expiry is configured.
+	*/
+	const { expiresIn, expiresAt } = prop.expiry;
+	let resolvedExpiresAt = null;
+	if (expiresAt !== void 0) resolvedExpiresAt = expiresAt instanceof Date ? expiresAt.getTime() : expiresAt;
+	else if (expiresIn !== void 0) resolvedExpiresAt = now + (typeof expiresIn === "number" ? expiresIn : string.milliseconds.parse(expiresIn));
+	onceProps[onceKey] = {
+		prop: key,
+		expiresAt: resolvedExpiresAt
+	};
+	return onceKey;
+}
+async function buildStandardVisitProps(pageProps, containerResolver, onceContext = {
+	exceptOnce: /* @__PURE__ */ new Set(),
+	now: Date.now()
+}, resetProps = /* @__PURE__ */ new Set(), mergeIntent = "append") {
+	const mergeProps = [];
+	const deepMergeProps = [];
+	const prependProps = [];
+	const matchPropsOn = [];
+	const newProps = {};
+	const deferredProps = {};
+	const onceProps = {};
+	const scrollProps = {};
+	const unpackedValues = [];
+	/**
+	* Classifies a single prop entry, mutating the accumulators above. Extracted
+	* so the once-prop path can unwrap and re-classify its inner prop through the
+	* exact same logic as a non-once prop.
+	*/
+	const classify = (key, value) => {
+		if (isObject(value)) {
+			/**
+			* Once props gate resolution on the client cache. We always record the
+			* caching metadata, then either skip the value (client already holds it)
+			* or unwrap and re-classify the inner prop. The client only advertises a
+			* once-key when it holds a present, non-expired value, so we trust the
+			* header and skip unless the prop is forced fresh.
+			*/
+			if (isOnceProp(value)) {
+				const onceKey = emitOnceMetadata(onceProps, key, value, onceContext.now);
+				if (!onceContext.exceptOnce.has(onceKey) || value.fresh) classify(key, value.value);
+				return;
+			}
+			/**
+			* Deferred props are skipped during the standard visits.
+			* But we inform the client about it
+			*/
+			if (isDeferredProp(value)) {
+				deferredProps[value.group] = deferredProps[value.group] ?? [];
+				deferredProps[value.group].push(key);
+				return;
+			}
+			/**
+			* Optional props are skipped during the standard visits
+			*/
+			if (isOptionalProp(value)) return;
+			/**
+			* Unpack always prop value
+			*/
+			if (isAlwaysProp(value)) {
+				unpackedValues.push({
+					key,
+					value: value.value
+				});
+				return;
+			}
+			/**
+			* Infinite-scroll props are mergeable, paginated props. We label the
+			* value's `data` array for keyed/directional merging per the client's
+			* merge intent, then resolve the value and its pagination cursor.
+			*/
+			if (isScrollProp(value)) {
+				/**
+				* A prop named in `X-Inertia-Reset` is left unlabeled so the client
+				* replaces rather than merges; the `reset` flag in `scrollProps` then
+				* tells it to discard cached items.
+				*/
+				if (!resetProps.has(key)) {
+					const { mergePath, matchEntry } = scrollMergeLabels(key, value);
+					if (mergeIntent === "prepend") prependProps.push(mergePath);
+					else mergeProps.push(mergePath);
+					if (matchEntry !== void 0) matchPropsOn.push(matchEntry);
+				}
+				/**
+				* A deferred scroll prop skips its first page on a standard visit; its
+				* cursor is emitted only once the value resolves (on the partial reload).
+				*/
+				if (value.group !== void 0) {
+					deferredProps[value.group] = deferredProps[value.group] ?? [];
+					deferredProps[value.group].push(key);
+					return;
+				}
+				unpackedValues.push({
+					key,
+					scroll: value
+				});
+				return;
+			}
+			/**
+			* Inform the client about the mergeable prop and use its
+			* value
+			*/
+			if (isMergeableProp(value)) {
+				/**
+				* A prop named in `X-Inertia-Reset` is left unlabeled so the client
+				* replaces it rather than merging; its value is still emitted below.
+				*/
+				if (!resetProps.has(key)) {
+					if (value[DEEP_MERGE]) deepMergeProps.push(key);
+					else if (value[MERGE_PREPEND]) prependProps.push(key);
+					else mergeProps.push(key);
+					if (value[MERGE_MATCH_ON] !== void 0) matchPropsOn.push(`${key}.${value[MERGE_MATCH_ON]}`);
+				}
+				/**
+				* Mergeable deferred props are skipped during the standard visits.
+				* But we inform the client about both of them
+				*/
+				if (isObject(value.value) && isDeferredProp(value.value)) {
+					deferredProps[value.value.group] = deferredProps[value.value.group] ?? [];
+					deferredProps[value.value.group].push(key);
+					return;
+				}
+				unpackedValues.push({
+					key,
+					value: value.value
+				});
+				return;
+			}
+			/**
+			* Unpack all other values
+			*/
+			unpackedValues.push({
+				key,
+				value
+			});
+		} else {
+			/**
+			* Compute lazy value
+			*/
+			if (typeof value === "function") {
+				unpackedValues.push({
+					key,
+					value
+				});
+				return;
+			}
+			newProps[key] = value;
+		}
+	};
+	for (const [key, value] of Object.entries(pageProps)) classify(key, value);
+	await Promise.all(unpackedValues.map(async (entry) => {
+		/**
+		* Scroll props resolve their value and pagination cursor together: invoke
+		* the value callback once, then compute the cursor via the prop's provider
+		* (the paginator-aware default unless an explicit one was supplied).
+		*/
+		if ("scroll" in entry) {
+			const { key, scroll: scrollProp } = entry;
+			let raw = scrollProp.value;
+			if (typeof raw === "function") raw = await raw();
+			const cursor = await scrollProp.provider(raw);
+			newProps[key] = await unpackPropValue(raw, containerResolver);
+			scrollProps[key] = {
+				...cursor,
+				reset: resetProps.has(key)
+			};
+			return;
+		}
+		const { key, value } = entry;
+		if (typeof value === "function") return Promise.resolve(value()).then((r) => unpackPropValue(r, containerResolver)).then((jsonValue) => {
+			newProps[key] = jsonValue;
+		});
+		else return unpackPropValue(value, containerResolver).then((jsonValue) => {
+			newProps[key] = jsonValue;
+		});
+	}));
+	return {
+		props: newProps,
+		mergeProps,
+		deepMergeProps,
+		prependProps,
+		matchPropsOn,
+		deferredProps,
+		onceProps,
+		scrollProps,
+		/**
+		* Deferred props are never computed on a standard visit, so nothing can be
+		* rescued here. Emitted for a uniform shape with the partial-reload builder
+		* and to match the always-present v3 `rescuedProps` wire field.
+		*/
+		rescuedProps: [],
+		rescuedErrors: []
+	};
+}
+/**
+* Builds props for partial (cherry-picked) Inertia requests.
+*
+* This function processes page props for partial requests where only specific
+* props are requested. It handles:
+* - Always props: Always included regardless of cherry picking
+* - Cherry-picked props: Only included if in the cherryPickProps list
+* - Mergeable props: Included and marked for merging
+* - Regular props: Included if cherry-picked
+*
+* @param pageProps - The page props to process
+* @param cherryPickProps - Array of prop names to include
+* @param containerResolver - Container resolver for dependency injection
+* @returns Promise resolving to object containing processed props and merge props list
+*
+* @example
+* ```js
+* const result = await buildPartialRequestProps(
+*   { user: { name: 'John' }, posts: defer(() => getPosts()), stats: optional(() => getStats()) },
+*   ['posts', 'stats']
+* )
+* // Returns: { props: { posts: [...], stats: [...] }, mergeProps: [], deferredProps: {} }
+* ```
+*/
+async function buildPartialRequestProps(pageProps, cherryPickProps, containerResolver, now = Date.now(), resetProps = /* @__PURE__ */ new Set(), mergeIntent = "append") {
+	const mergeProps = [];
+	const deepMergeProps = [];
+	const prependProps = [];
+	const matchPropsOn = [];
+	const newProps = {};
+	const onceProps = {};
+	const scrollProps = {};
+	const unpackedValues = [];
+	const rescuedProps = [];
+	const rescuedErrors = [];
+	/**
+	* Classifies a single prop entry, mutating the accumulators above. Extracted
+	* so the once-prop path can unwrap and re-classify its inner prop through the
+	* exact same logic as a non-once prop.
+	*/
+	const classify = (key, value) => {
+		if (isObject(value)) {
+			/**
+			* Unpack always prop even if it is not part of
+			* cherry picking props
+			*/
+			if (isAlwaysProp(value)) {
+				unpackedValues.push({
+					key,
+					value: value.value
+				});
+				return;
+			}
+			/**
+			* Skip key if not part of cherry picking list
+			*/
+			if (!cherryPickProps.includes(key)) return;
+			/**
+			* Partial reloads always resolve a requested once prop — the
+			* `X-Inertia-Except-Once-Props` header is honoured on standard visits
+			* only (matching inertia-laravel, whose once-cache gate runs only when
+			* the request is not partial). We still emit the caching metadata.
+			*/
+			if (isOnceProp(value)) {
+				emitOnceMetadata(onceProps, key, value, now);
+				classify(key, value.value);
+				return;
+			}
+			/**
+			* Unpack deferred prop
+			*/
+			if (isDeferredProp(value)) {
+				unpackedValues.push({
+					key,
+					value: value.compute,
+					rescue: value.rescue
+				});
+				return;
+			}
+			/**
+			* Unpack optional prop
+			*/
+			if (isOptionalProp(value)) {
+				unpackedValues.push({
+					key,
+					value: value.compute
+				});
+				return;
+			}
+			/**
+			* Resolve a requested scroll prop: label its `data` array for the merge
+			* per the client's intent, then resolve the value and emit its cursor.
+			*/
+			if (isScrollProp(value)) {
+				if (!resetProps.has(key)) {
+					const { mergePath, matchEntry } = scrollMergeLabels(key, value);
+					if (mergeIntent === "prepend") prependProps.push(mergePath);
+					else mergeProps.push(mergePath);
+					if (matchEntry !== void 0) matchPropsOn.push(matchEntry);
+				}
+				unpackedValues.push({
+					key,
+					scroll: value
+				});
+				return;
+			}
+			/**
+			* Inform the client about the mergeable prop
+			*/
+			if (isMergeableProp(value)) {
+				/**
+				* A prop named in `X-Inertia-Reset` is left unlabeled so the client
+				* replaces it rather than merging; its value is still emitted below.
+				*/
+				if (!resetProps.has(key)) {
+					if (value[DEEP_MERGE]) deepMergeProps.push(key);
+					else if (value[MERGE_PREPEND]) prependProps.push(key);
+					else mergeProps.push(key);
+					if (value[MERGE_MATCH_ON] !== void 0) matchPropsOn.push(`${key}.${value[MERGE_MATCH_ON]}`);
+				}
+				/**
+				* Unpack deferred mergeable prop
+				*/
+				if (isObject(value.value) && isDeferredProp(value.value)) unpackedValues.push({
+					key,
+					value: value.value.compute,
+					rescue: value.value.rescue
+				});
+				else unpackedValues.push({
+					key,
+					value: value.value
+				});
+				return;
+			}
+			/**
+			* Unpack all other values
+			*/
+			unpackedValues.push({
+				key,
+				value
+			});
+		} else {
+			/**
+			* Skip key if not part of cherry picking list
+			*/
+			if (!cherryPickProps.includes(key)) return;
+			/**
+			* Compute lazy value
+			*/
+			if (typeof value === "function") {
+				unpackedValues.push({
+					key,
+					value
+				});
+				return;
+			}
+			newProps[key] = value;
+		}
+	};
+	for (const [key, value] of Object.entries(pageProps)) classify(key, value);
+	await Promise.all(unpackedValues.map(async (entry) => {
+		/**
+		* Scroll props resolve their value and pagination cursor together: invoke
+		* the value callback once, then compute the cursor via the prop's provider
+		* (the paginator-aware default unless an explicit one was supplied).
+		*/
+		if ("scroll" in entry) {
+			const { key, scroll: scrollProp } = entry;
+			let raw = scrollProp.value;
+			if (typeof raw === "function") raw = await raw();
+			const cursor = await scrollProp.provider(raw);
+			newProps[key] = await unpackPropValue(raw, containerResolver);
+			scrollProps[key] = {
+				...cursor,
+				reset: resetProps.has(key)
+			};
+			return;
+		}
+		const { key, value, rescue } = entry;
+		/**
+		* A rescuable deferred prop swallows a resolution error: the value is
+		* omitted from `props` (never emitted as `null`), the path is recorded in
+		* `rescuedProps`, and the error is collected for out-of-band reporting so
+		* it never propagates into the response pipeline.
+		*/
+		if (rescue) {
+			try {
+				const resolved = typeof value === "function" ? await value() : value;
+				newProps[key] = await unpackPropValue(resolved, containerResolver);
+			} catch (error) {
+				rescuedProps.push(key);
+				rescuedErrors.push({
+					prop: key,
+					error
+				});
+			}
+			return;
+		}
+		if (typeof value === "function") return Promise.resolve(value()).then((r) => unpackPropValue(r, containerResolver)).then((jsonValue) => {
+			newProps[key] = jsonValue;
+		});
+		else return unpackPropValue(value, containerResolver).then((jsonValue) => {
+			newProps[key] = jsonValue;
+		});
+	}));
+	return {
+		props: newProps,
+		mergeProps,
+		deepMergeProps,
+		prependProps,
+		matchPropsOn,
+		deferredProps: {},
+		onceProps,
+		scrollProps,
+		rescuedProps,
+		rescuedErrors
+	};
+}
+//#endregion
+//#region src/inertia.ts
+/**
+* Main class used to interact with Inertia
+*
+* Provides a complete interface for handling Inertia.js requests, rendering pages,
+* managing props, and controlling page navigation behavior.
+*
+* @example
+* ```js
+* const inertia = new Inertia(ctx, config, vite, serverRenderer)
+*
+* // Render a page
+* const result = await inertia.render('Home', { user: { name: 'John' } })
+*
+* // Clear browser history
+* inertia.clearHistory()
+*
+* // Redirect to a different location
+* inertia.location('/dashboard')
+* ```
+*/
+var Inertia = class Inertia {
+	ctx;
+	config;
+	/**
+	* Listener invoked when a rescuable deferred prop's resolution throws. Shared
+	* across all per-request instances; defaults to logging the error through the
+	* request logger.
+	*/
+	static #rescueListener = (error, { prop, ctx }) => {
+		ctx.logger.error({ err: error }, `Rescued deferred prop "${prop}"`);
+	};
+	/**
+	* Register a global listener for rescued deferred-prop errors. The listener
+	* receives the thrown error along with the failing prop path and the HTTP
+	* context. Call with no argument to restore the default logger-based reporter.
+	*
+	* @example
+	* ```ts
+	* Inertia.onRescue((error, { prop, ctx }) => {
+	*   ctx.logger.error({ err: error }, `deferred prop "${prop}" failed`)
+	* })
+	* ```
+	*/
+	static onRescue(listener) {
+		Inertia.#rescueListener = listener ?? ((error, { prop, ctx }) => {
+			ctx.logger.error({ err: error }, `Rescued deferred prop "${prop}"`);
+		});
+	}
+	#sharedStateProviders;
+	/**
+	* Provider for the page object's top-level `flash` field. Registered by the
+	* Inertia middleware from its `flash()` method; resolved once per response.
+	*/
+	#flashProvider;
+	#cachedRequestInfo;
+	/**
+	* Optional server-side renderer for SSR functionality
+	*/
+	#serverRenderer;
+	/**
+	* Vite instance for asset management and manifest handling
+	*/
+	#vite;
+	/**
+	* Flag to control whether the next navigation should clear browser history
+	*/
+	#shouldClearHistory;
+	/**
+	* Flag to control whether browser history should be encrypted
+	*/
+	#shouldEncryptHistory;
+	/**
+	* Cached version string/number for asset versioning
+	*/
+	#cachedVersion;
+	/**
+	* Defer prop evaluation until client-side rendering
+	*
+	* @example
+	* ```js
+	* {
+	*   expensiveData: inertia.defer(() => computeExpensiveData())
+	* }
+	* ```
+	*/
+	defer = defer;
+	/**
+	* Always include prop in both server and client renders
+	*
+	* @example
+	* ```js
+	* {
+	*   currentUser: inertia.always(() => getCurrentUser())
+	* }
+	* ```
+	*/
+	always = always;
+	/**
+	* Merge prop with existing client-side data
+	*
+	* @example
+	* ```js
+	* {
+	*   posts: inertia.merge(() => getPosts())
+	* }
+	* ```
+	*/
+	merge = merge;
+	/**
+	* Include prop only when specifically requested
+	*
+	* @example
+	* ```js
+	* {
+	*   optionalData: inertia.optional(() => getOptionalData())
+	* }
+	* ```
+	*/
+	optional = optional;
+	/**
+	* Deep merge prop with existing client-side data
+	*
+	* @example
+	* ```js
+	* {
+	*   settings: inertia.deepMerge(() => getSettings())
+	* }
+	* ```
+	*/
+	deepMerge = deepMerge;
+	/**
+	* Remember a prop on the client across visits. The server skips re-resolving
+	* it when the client reports a fresh cached value. Compose with
+	* `defer`/`optional`/`merge` via their `.once()` method.
+	*
+	* @example
+	* ```js
+	* {
+	*   lookups: inertia.once(() => loadLookupTables(), { expiresIn: '1h' })
+	* }
+	* ```
+	*/
+	once = once;
+	/**
+	* Create an infinite-scroll prop: a paginated value the client keeps extending
+	* as the user scrolls. The cursor is auto-derived from a transformer paginator,
+	* or supplied via a provider callback for other sources.
+	*
+	* @example
+	* ```js
+	* {
+	*   users: inertia.scroll(() => UserTransformer.paginate(rows, paginator.getMeta()))
+	* }
+	* ```
+	*/
+	scroll = scroll;
+	/**
+	* Creates a new Inertia instance
+	*
+	* @param ctx - HTTP context for the current request
+	* @param config - Inertia configuration object
+	* @param vite - Vite instance for asset management
+	* @param serverRenderer - Optional server renderer for SSR
+	*
+	* @example
+	* ```js
+	* const inertia = new Inertia(ctx, {
+	*   rootView: 'app',
+	*   ssr: { enabled: true }
+	* }, vite, serverRenderer)
+	* ```
+	*/
+	constructor(ctx, config, vite, serverRenderer) {
+		this.ctx = ctx;
+		this.config = config;
+		if (debug_default.enabled) debug_default("instantiating inertia instance for request \"%s\" using config %O", ctx.request.url(), this.config);
+		this.#shouldClearHistory = false;
+		this.#vite = vite;
+		this.#serverRenderer = serverRenderer;
+		this.#shouldEncryptHistory = config.encryptHistory ?? false;
+		this.#cachedVersion = this.config.assetsVersion ? String(this.config.assetsVersion) : void 0;
+	}
+	/**
+	* Resolve the root view template
+	*
+	* Handles both static strings and dynamic functions for the root view.
+	*
+	* @example
+	* ```js
+	* const viewName = this.#resolveRootView()
+	* this.ctx.view.render(viewName, { page: pageObject })
+	* ```
+	*/
+	#resolveRootView() {
+		return typeof this.config.rootView === "function" ? this.config.rootView(this.ctx) : this.config.rootView;
+	}
+	/**
+	* Constructs and serializes the page props for a given component
+	*
+	* Handles both full page loads and partial requests with prop filtering.
+	* Merges shared state providers with page-specific props, and handles
+	* prop cherry-picking for partial reloads based on the `only` and `except` parameters.
+	*
+	* @param component - The component name being rendered
+	* @param requestInfo - Information about the current request
+	* @param pageProps - Raw page props to be processed
+	*
+	* @example
+	* ```js
+	* const result = await this.#buildPageProps('Dashboard', requestInfo, {
+	*   user: { name: 'John' },
+	*   posts: defer(() => getPosts())
+	* })
+	* ```
+	*/
+	async #buildPageProps(component, requestInfo, pageProps) {
+		let finalProps;
+		/**
+		* Top-level keys registered through the `share()` pipeline, in registration
+		* order. Emitted verbatim as the page object's `sharedProps` field —
+		* independent of which shared props actually make it into the response.
+		*/
+		let sharedKeys = [];
+		/**
+		* Shared state could be defined as functions that must be lazily evaluated.
+		* Therefore we invoke all the functions and create a final merged shared
+		* state.
+		*/
+		if (this.#sharedStateProviders) {
+			const sharedState = await Promise.all(this.#sharedStateProviders.map((provider) => {
+				return typeof provider === "function" ? provider() : provider;
+			})).then((resolvedSharedState) => {
+				return resolvedSharedState.reduce((result, state) => {
+					return {
+						...result,
+						...state
+					};
+				}, {});
+			});
+			sharedKeys = Object.keys(sharedState);
+			finalProps = {
+				...sharedState,
+				...pageProps
+			};
+		} else finalProps = { ...pageProps };
+		/**
+		* Reference timestamp used to normalize relative once-prop expiry for this
+		* response.
+		*/
+		const now = Date.now();
+		/**
+		* Prop paths the client asked to reset (via `X-Inertia-Reset`). Reset props
+		* are emitted unlabeled so the client replaces them instead of merging.
+		*/
+		const resetProps = new Set(requestInfo.resetProps ?? []);
+		if (requestInfo.partialComponent === component) {
+			const only = requestInfo.onlyProps;
+			const except = requestInfo.exceptProps ?? [];
+			const cherryPickProps = Object.keys(finalProps).filter((propName) => {
+				if (only) return only.includes(propName) && !except.includes(propName);
+				return !except.includes(propName);
+			});
+			debug_default("building props for a partial reload %O", requestInfo);
+			debug_default("cherry picking props %s", cherryPickProps);
+			/**
+			* `sharedProps` reports the registered shared keys, not a subset of the
+			* emitted props — so cherry-picking does not narrow it (mirrors
+			* inertia-laravel, which collects the keys before partial filtering).
+			*/
+			return {
+				...await buildPartialRequestProps(finalProps, cherryPickProps, this.ctx.containerResolver, now, resetProps, requestInfo.mergeIntent),
+				sharedProps: sharedKeys
+			};
+		}
+		/**
+		* Standard visits gate once props on the client cache: the set of once-keys
+		* the client already holds, plus the reference timestamp.
+		*/
+		const onceContext = {
+			exceptOnce: new Set(requestInfo.exceptOnceProps ?? []),
+			now
+		};
+		debug_default("building props for a standard visit %O", requestInfo);
+		/**
+		* Emit every registered shared key, including those skipped this visit as
+		* deferred/optional — the client still treats them as shared for
+		* instant-visit carry-over.
+		*/
+		return {
+			...await buildStandardVisitProps(finalProps, this.ctx.containerResolver, onceContext, resetProps, requestInfo.mergeIntent),
+			sharedProps: sharedKeys
+		};
+	}
+	/**
+	* Handle Inertia AJAX request by setting appropriate headers
+	*
+	* Sets the `X-Inertia` header to 'true' indicating this is an Inertia response,
+	* then returns the page object which will be serialized as JSON.
+	*
+	* @param pageObject - The page object to return
+	*
+	* @example
+	* ```js
+	* const pageObj = await this.page('Dashboard', props)
+	* return this.#handleInertiaRequest(pageObj)
+	* ```
+	*/
+	#handleInertiaRequest(pageObject) {
+		this.ctx.response.header(InertiaHeaders.Inertia, "true");
+		return pageObject;
+	}
+	/**
+	* Render page with server-side rendering
+	*
+	* @param pageObject - The page object to render
+	* @param viewProps - Additional props to pass to the root view template
+	* @returns Promise resolving to the rendered HTML string
+	*/
+	async #renderWithSSR(pageObject, viewProps) {
+		if (!this.#serverRenderer) throw new Error("Cannot server render pages without a server renderer");
+		debug_default("server-side rendering %O", pageObject);
+		const { head, body } = await this.#serverRenderer.render(pageObject);
+		return this.ctx.view.render(this.#resolveRootView(), {
+			page: {
+				ssrHead: head,
+				ssrBody: body,
+				...pageObject
+			},
+			...viewProps
+		});
+	}
+	/**
+	* Render page with client-side rendering only
+	*
+	* @param pageObject - The page object to render
+	* @param viewProps - Additional props to pass to the root view template
+	* @returns Promise resolving to the rendered HTML string
+	*/
+	async #renderClientSide(pageObject, viewProps) {
+		debug_default("rendering shell for SPA %O", pageObject);
+		return this.ctx.view.render(this.#resolveRootView(), {
+			page: pageObject,
+			...viewProps
+		});
+	}
+	/**
+	* Extract Inertia-specific information from request headers
+	*
+	* Parses various Inertia headers to determine request type and props filtering.
+	*
+	* @param reCompute - Whether to recompute the request info instead of using cached version
+	* @returns The request information object containing Inertia-specific data
+	*
+	* @example
+	* ```js
+	* const info = inertia.requestInfo()
+	* if (info.isInertiaRequest) {
+	*   // Handle as Inertia request
+	* }
+	* ```
+	*/
+	requestInfo(reCompute) {
+		if (reCompute) this.#cachedRequestInfo = void 0;
+		this.#cachedRequestInfo = this.#cachedRequestInfo ?? {
+			version: this.ctx.request.header(InertiaHeaders.Version),
+			isInertiaRequest: !!this.ctx.request.header(InertiaHeaders.Inertia),
+			isPartialRequest: !!this.ctx.request.header(InertiaHeaders.PartialComponent),
+			partialComponent: this.ctx.request.header(InertiaHeaders.PartialComponent),
+			onlyProps: this.ctx.request.header(InertiaHeaders.PartialOnly)?.split(","),
+			exceptProps: this.ctx.request.header(InertiaHeaders.PartialExcept)?.split(","),
+			resetProps: this.ctx.request.header(InertiaHeaders.Reset)?.split(","),
+			errorBag: this.ctx.request.header(InertiaHeaders.ErrorBag),
+			exceptOnceProps: this.ctx.request.header(InertiaHeaders.ExceptOnceProps)?.split(","),
+			mergeIntent: this.ctx.request.header(InertiaHeaders.InfiniteScrollMergeIntent) === "prepend" ? "prepend" : "append"
+		};
+		return this.#cachedRequestInfo;
+	}
+	/**
+	* Compute and cache the assets version
+	*
+	* Uses Vite manifest hash when available, otherwise defaults to '1'.
+	*
+	* @returns The computed version string for asset versioning
+	*/
+	getVersion() {
+		if (this.#cachedVersion) return this.#cachedVersion;
+		if (this.#vite?.hasManifestFile) this.#cachedVersion = createHash("md5").update(JSON.stringify(this.#vite.manifest())).digest("hex");
+		else this.#cachedVersion = "1";
+		return this.#cachedVersion;
+	}
+	/**
+	* Determine if server-side rendering is enabled for a specific component
+	*
+	* Checks global SSR settings and component-specific configuration.
+	*
+	* @param component - The component name to check
+	* @returns Promise resolving to true if SSR is enabled for the component
+	*
+	* @example
+	* ```js
+	* const shouldSSR = await inertia.ssrEnabled('UserProfile')
+	* if (shouldSSR) {
+	*   // Render on server
+	* }
+	* ```
+	*/
+	async ssrEnabled(component) {
+		if (!this.config.ssr.enabled) return false;
+		if (typeof this.config.ssr.pages === "function") return this.config.ssr.pages(this.ctx, component);
+		if (this.config.ssr.pages) return this.config.ssr.pages?.includes(component);
+		return true;
+	}
+	/**
+	* Share props across all pages
+	*
+	* Merges the provided props with existing shared state, making them available
+	* to all pages rendered by this Inertia instance. Shared props are included
+	* in every page render alongside page-specific props.
+	*
+	* @param sharedState - Props to share across all pages
+	* @returns The Inertia instance for method chaining
+	*
+	* @example
+	* ```js
+	* // Share user data across all pages
+	* inertia.share({
+	*   user: getCurrentUser(),
+	*   flash: getFlashMessages()
+	* })
+	*
+	* // Chain multiple shares
+	* inertia
+	*   .share({ currentUser: user })
+	*   .share({ permissions: userPermissions })
+	* ```
+	*/
+	share(sharedState) {
+		if (!this.#sharedStateProviders) this.#sharedStateProviders = [];
+		this.#sharedStateProviders.push(sharedState);
+		return this;
+	}
+	/**
+	* Register the provider for the page object's top-level `flash` field.
+	*
+	* Unlike shared state, the resolved value is emitted as a sibling of `props`
+	* (not merged into them). The Inertia middleware calls this with its `flash()`
+	* method; the last registration wins. When no provider is registered, the
+	* `flash` field is omitted from the page object entirely.
+	*
+	* @param provider - Callback resolving the flash bag for this response
+	* @returns The Inertia instance for method chaining
+	*
+	* @example
+	* ```js
+	* inertia.flash(() => ctx.session.flashMessages.all())
+	* ```
+	*/
+	flash(provider) {
+		this.#flashProvider = provider;
+		return this;
+	}
+	/**
+	* Build a page object with processed props and metadata
+	*
+	* Creates the complete page object that will be sent to the client or used for SSR.
+	*
+	* @param page - The page component name
+	* @param pageProps - Props to pass to the page component
+	* @returns Promise resolving to the complete page object
+	*
+	* @example
+	* ```js
+	* const pageObject = await inertia.page('Dashboard', {
+	*   user: { name: 'John' },
+	*   posts: defer(() => getPosts())
+	* })
+	* ```
+	*/
+	async page(page, pageProps) {
+		const requestInfo = this.requestInfo();
+		const { props, mergeProps, deferredProps, deepMergeProps, prependProps, matchPropsOn, onceProps, scrollProps, rescuedProps, rescuedErrors, sharedProps } = await this.#buildPageProps(page, requestInfo, pageProps);
+		/**
+		* Report any rescued deferred-prop errors out of band through the registered
+		* listener (the logger-based default unless an app overrode it). The errors
+		* were already caught during resolution, so this never affects the response.
+		*/
+		for (const { prop, error } of rescuedErrors) Inertia.#rescueListener(error, {
+			prop,
+			ctx: this.ctx
+		});
+		const pageObject = {
+			component: page,
+			url: this.ctx.request.url(true),
+			version: this.getVersion(),
+			props,
+			deferredProps,
+			mergeProps,
+			deepMergeProps,
+			prependProps,
+			matchPropsOn,
+			onceProps,
+			scrollProps,
+			rescuedProps
+		};
+		/**
+		* Advertise the registered shared keys so the v3 client can carry shared
+		* props over during instant visits. Omitted when no shared keys exist, so the
+		* default wire format is unchanged (matches inertia-laravel, which drops the
+		* field when empty).
+		*/
+		if (sharedProps.length > 0) pageObject.sharedProps = sharedProps;
+		/**
+		* Inertia v3 omits `clearHistory` and `encryptHistory` from the page object
+		* unless they are `true` (the client defaults both to `false` when absent).
+		* We only emit them when enabled to match the v3 wire format.
+		*/
+		if (this.#shouldClearHistory) pageObject.clearHistory = true;
+		if (this.#shouldEncryptHistory) pageObject.encryptHistory = true;
+		/**
+		* Resolve the first-class flash bag from the registered provider, if any,
+		* and emit it as a top-level field. Omitted entirely when no provider is
+		* registered, so the default wire format stays unchanged.
+		*/
+		if (this.#flashProvider) pageObject.flash = await this.#flashProvider();
+		return pageObject;
+	}
+	/**
+	* Render a page using Inertia
+	*
+	* This method handles three distinct rendering scenarios:
+	* 1. Inertia requests - Returns JSON page object for client-side navigation
+	* 2. Initial page loads with SSR - Returns HTML with server-rendered content
+	* 3. Initial page loads without SSR - Returns HTML for client-side hydration
+	*
+	* @param page - The page component name to render
+	* @param pageProps - Props to pass to the page component
+	* @param viewProps - Additional props to pass to the root view template
+	* @returns Promise resolving to PageObject for Inertia requests, HTML string for initial page loads
+	*
+	* @example
+	* ```js
+	* // For Inertia requests, returns PageObject
+	* const result = await inertia.render('Profile', {
+	*   user: getCurrentUser(),
+	*   posts: defer(() => getUserPosts())
+	* })
+	*
+	* // For initial page loads, returns HTML string
+	* const html = await inertia.render('Home', { welcome: 'Hello World' })
+	* ```
+	*/
+	async render(page, pageProps, viewProps) {
+		const requestInfo = this.requestInfo();
+		const pageObject = await this.page(page, pageProps);
+		if (requestInfo.isInertiaRequest) return this.#handleInertiaRequest(pageObject);
+		if (await this.ssrEnabled(page)) return this.#renderWithSSR(pageObject, viewProps);
+		/**
+		* Fallback to client-side rendering
+		*/
+		return this.#renderClientSide(pageObject, viewProps);
+	}
+	/**
+	* Clear the browser history on the next navigation
+	*
+	* Instructs the client to clear the browser history stack when navigating.
+	*
+	* @example
+	* ```js
+	* inertia.clearHistory()
+	* return inertia.render('Dashboard', props)
+	* ```
+	*/
+	clearHistory() {
+		this.#shouldClearHistory = true;
+	}
+	/**
+	* Control whether browser history should be encrypted
+	*
+	* Enables or disables encryption of sensitive data in browser history.
+	*
+	* @param encrypt - Whether to encrypt history (defaults to true)
+	*
+	* @example
+	* ```js
+	* // Enable encryption for sensitive pages
+	* inertia.encryptHistory(true)
+	*
+	* // Disable encryption for public pages
+	* inertia.encryptHistory(false)
+	* ```
+	*/
+	encryptHistory(encrypt = true) {
+		this.#shouldEncryptHistory = encrypt;
+	}
+	/**
+	* Redirect to a different location
+	*
+	* Sets the appropriate headers to redirect the client to a new URL.
+	* Uses a 409 status code which Inertia.js interprets as a redirect instruction.
+	*
+	* @param url - The URL to redirect to
+	*
+	* @example
+	* ```js
+	* // Redirect after login
+	* inertia.location('/dashboard')
+	*
+	* // Redirect with full URL
+	* inertia.location('https://example.com/external')
+	* ```
+	*/
+	location(url) {
+		this.ctx.response.header(InertiaHeaders.Location, url);
+		this.ctx.response.status(409);
+	}
+};
+//#endregion
+//#region src/server_renderer.ts
+/**
+* Server-side renderer for Inertia.js applications.
+*
+* Resolves the SSR entrypoint through `vite.loadServerModule` so the same
+* code path works in dev (Vite module runner) and in production (pre-built
+* SSR bundle on disk). The entry must be declared under `serverEntrypoints`
+* on the AdonisJS Vite plugin so it gets bundled for production.
+*
+* @example
+* ```typescript
+* const renderer = new ServerRenderer(config, vite)
+* const { head, body } = await renderer.render(pageObject)
+* ```
+*/
+var ServerRenderer = class {
+	/**
+	* Inertia configuration object containing SSR settings
+	*/
+	#config;
+	/**
+	* Vite instance used to load the SSR entrypoint module
+	*/
+	#vite;
+	constructor(config, vite) {
+		this.#config = config;
+		this.#vite = vite;
+	}
+	/**
+	* Renders an Inertia page on the server.
+	*
+	* @param pageObject - The Inertia page object containing component, props, and metadata
+	* @returns Promise resolving to an object with rendered head and body HTML
+	*/
+	async render(pageObject) {
+		debug_default("rendering page through SSR entrypoint %s", this.#config.ssr.entrypoint);
+		const result = await (await this.#vite.loadServerModule(this.#config.ssr.entrypoint)).default(pageObject);
+		debug_default("SSR bundle %o", result);
+		return {
+			head: result.head,
+			body: result.body
+		};
+	}
+};
+//#endregion
+//#region src/inertia_manager.ts
+/**
+* Manager class for managing Inertia instances
+*
+* Acts as a factory for creating Inertia instances with shared configuration
+* and Vite integration.
+*
+* @example
+* ```js
+* const manager = new InertiaManager(config, vite)
+* const inertia = manager.createForRequest(ctx)
+* ```
+*/
+var InertiaManager = class {
+	/**
+	* Optional Vite instance for asset management
+	*/
+	#vite;
+	/**
+	* Inertia configuration object
+	*/
+	#config;
+	#serverRenderer;
+	/**
+	* Creates a new InertiaManager instance
+	*
+	* @param config - Inertia configuration object
+	* @param vite - Optional Vite instance for development mode and SSR
+	*
+	* @example
+	* ```js
+	* const manager = new InertiaManager({
+	*   rootView: 'app',
+	*   ssr: { enabled: true }
+	* }, vite)
+	* ```
+	*/
+	constructor(config, vite) {
+		this.#config = config;
+		this.#vite = vite;
+		this.#serverRenderer = this.#vite ? new ServerRenderer(this.#config, this.#vite) : void 0;
+	}
+	/**
+	* Creates a new Inertia instance for a specific HTTP request
+	*
+	* @param ctx - HTTP context for the current request
+	* @returns A new Inertia instance configured for the given request
+	*
+	* @example
+	* ```js
+	* const inertia = manager.createForRequest(ctx)
+	* await inertia.render('Home', { user: ctx.auth.user })
+	* ```
+	*/
+	createForRequest(ctx) {
+		return new Inertia(ctx, this.#config, this.#vite, this.#serverRenderer);
+	}
+};
+//#endregion
+export { symbols_exports as i, ServerRenderer as n, Inertia as r, InertiaManager as t };