@blacklizard/inertia-express 2.0.0 → 3.1.0

package/dist/core-PN_yVSCS.js

@@ -0,0 +1,1741 @@
+import { createHash } from "node:crypto";
+//#region src/core/prop-descriptor.ts
+/**
+* Wrap a value in a list the way Laravel's `Arr::wrap` does: `undefined` and
+* `null` (a plain-JS caller omitting an option) become an empty list.
+*/
+function wrapList(value) {
+	if (value === void 0 || value === null) return [];
+	return Array.isArray(value) ? [...value] : [value];
+}
+const MERGE_LIVE_MESSAGE = "Live updates are not supported on merge properties.";
+/** Name prefix the broadcaster adds for each channel type; never sent to the client. */
+const CHANNEL_PREFIXES = {
+	public: "",
+	private: "private-",
+	presence: "presence-",
+	"encrypted-private": "private-encrypted-"
+};
+/**
+* Normalise one channel input into a {@link LiveChannel}: a bare string is
+* public; an object's type is validated and its type prefix stripped from the name.
+*
+* @param input Bare channel name or explicit channel.
+*/
+function normalizeChannel(input) {
+	if (typeof input === "string") return {
+		name: input,
+		type: "public"
+	};
+	if (!Object.hasOwn(CHANNEL_PREFIXES, input.type)) throw new TypeError(`Unknown live channel type [${String(input.type)}]. Use public, private, presence or encrypted-private.`);
+	const prefix = CHANNEL_PREFIXES[input.type];
+	return {
+		name: prefix !== "" && input.name.startsWith(prefix) ? input.name.slice(prefix.length) : input.name,
+		type: input.type
+	};
+}
+/**
+* A prop wrapped with resolution and merge behaviour, ported from
+* inertia-laravel's prop classes and their `MergesProps`, `DefersProps`
+* and `ResolvesOnce` traits. The descriptor holds the wrapped value by
+* reference and never mutates it.
+*/
+var PropDescriptor = class {
+	kind;
+	source;
+	ignoreFirstLoad = false;
+	defers = false;
+	group = "default";
+	merges = false;
+	deep = false;
+	appends = true;
+	appendPaths = [];
+	prependPaths = [];
+	matchOnPaths = [];
+	resolvesOnce = false;
+	onceKey = null;
+	ttlSeconds = null;
+	expiresAtDate = null;
+	isFresh = false;
+	rescues = false;
+	isAlways = false;
+	isScroll = false;
+	wrapper = "data";
+	scrollMetadata = null;
+	liveDeclarations = [];
+	liveThrottle = null;
+	/**
+	* Create a descriptor around a prop source.
+	*
+	* @param kind The constructor that produced this descriptor.
+	* @param source The plain value or producer function being wrapped.
+	*/
+	constructor(kind, source) {
+		this.kind = kind;
+		this.source = source;
+	}
+	/**
+	* `true` when the prop appends at its root: the append flag is set and no
+	* append/prepend paths were recorded.
+	*/
+	get appendsAtRoot() {
+		return this.appends && this.mergesAtRoot();
+	}
+	/**
+	* `true` when the prop prepends at its root: the append flag is cleared and
+	* no append/prepend paths were recorded.
+	*/
+	get prependsAtRoot() {
+		return !this.appends && this.mergesAtRoot();
+	}
+	/**
+	* `true` once at least one live declaration was recorded.
+	*/
+	get isLive() {
+		return this.liveDeclarations.length > 0;
+	}
+	/**
+	* Mark the prop for a shallow client-side merge. Throws when the prop is live.
+	*/
+	merge() {
+		if (this.isLive) throw new Error(MERGE_LIVE_MESSAGE);
+		this.merges = true;
+		return this;
+	}
+	/**
+	* Mark the prop for a deep client-side merge.
+	*/
+	deepMerge() {
+		this.deep = true;
+		return this.merge();
+	}
+	/**
+	* Configure appending. A boolean sets the root append flag; a string
+	* records an append path; a list records each path; a record maps each
+	* path to its match-on field.
+	*
+	* @param path Root flag, path, list of paths, or path-to-matchOn record.
+	* @param matchOn Field to dedupe on, recorded as `path.matchOn` when `path` is a string.
+	*/
+	append(path = true, matchOn) {
+		if (typeof path === "boolean") this.appends = path;
+		else if (typeof path === "string") {
+			this.appendPaths.push(path);
+			this.recordMatchOn(path, matchOn);
+		} else if (Array.isArray(path)) path.forEach((entry) => this.append(entry));
+		else Object.entries(path).forEach(([key, field]) => this.append(key, field));
+		return this;
+	}
+	/**
+	* Configure prepending. A boolean clears (or sets) the root append flag; a
+	* string records a prepend path; a list records each path; a record maps
+	* each path to its match-on field.
+	*
+	* @param path Root flag, path, list of paths, or path-to-matchOn record.
+	* @param matchOn Field to dedupe on, recorded as `path.matchOn` when `path` is a string.
+	*/
+	prepend(path = true, matchOn) {
+		if (typeof path === "boolean") this.appends = !path;
+		else if (typeof path === "string") {
+			this.prependPaths.push(path);
+			this.recordMatchOn(path, matchOn);
+		} else if (Array.isArray(path)) path.forEach((entry) => this.prepend(entry));
+		else Object.entries(path).forEach(([key, field]) => this.prepend(key, field));
+		return this;
+	}
+	/**
+	* Replace the match-on paths the client dedupes merged items by.
+	*
+	* @param path A single path or a list of paths.
+	*/
+	matchOn(path) {
+		this.matchOnPaths = Array.isArray(path) ? [...path] : [path];
+		return this;
+	}
+	/**
+	* Defer the prop to a follow-up request.
+	*
+	* @param group Load group; props sharing a group are fetched together. Defaults to `'default'`.
+	*/
+	defer(group) {
+		this.defers = true;
+		this.group = group ?? "default";
+		return this;
+	}
+	/**
+	* Toggle once-resolution, optionally setting its key and expiry.
+	*
+	* @param value Whether the prop resolves once. Defaults to `true`.
+	* @param as Custom once key.
+	* @param until TTL in seconds, or an absolute expiry date.
+	*/
+	once(value = true, as, until) {
+		this.resolvesOnce = value;
+		if (as !== void 0) this.as(as);
+		if (until !== void 0) this.until(until);
+		return this;
+	}
+	/**
+	* Set the key the client caches a once-prop under.
+	*
+	* @param key The once key.
+	*/
+	as(key) {
+		this.onceKey = key;
+		return this;
+	}
+	/**
+	* Set the once-prop's expiry, replacing any expiry set by an earlier call.
+	*
+	* @param delay TTL in seconds, or an absolute expiry date.
+	*/
+	until(delay) {
+		if (delay instanceof Date) {
+			this.expiresAtDate = delay;
+			this.ttlSeconds = null;
+		} else {
+			this.ttlSeconds = delay;
+			this.expiresAtDate = null;
+		}
+		return this;
+	}
+	/**
+	* Force a once-prop to be re-resolved.
+	*
+	* @param value Whether to refresh. Defaults to `true`.
+	*/
+	fresh(value = true) {
+		this.isFresh = value;
+		return this;
+	}
+	/**
+	* Opt into rescuing errors thrown while resolving the prop.
+	*
+	* @param value Whether to rescue. Defaults to `true`.
+	*/
+	rescue(value = true) {
+		this.rescues = value;
+		return this;
+	}
+	/**
+	* The once-prop's expiry as a millisecond epoch, or `null` without a TTL or date.
+	*
+	* @param now Current time in milliseconds. Defaults to `Date.now()`.
+	*/
+	expiresAt(now = Date.now()) {
+		if (this.expiresAtDate !== null) return this.expiresAtDate.getTime();
+		if (this.ttlSeconds !== null) return now + this.ttlSeconds * 1e3;
+		return null;
+	}
+	/**
+	* Declare events (and the channels they arrive on) that refresh the prop.
+	* May be called more than once; a later throttle replaces an earlier one.
+	* Throws on a merge prop or an unknown channel type.
+	*
+	* @param options Events, channels and optional throttle in milliseconds.
+	*/
+	live(options) {
+		if (this.merges) throw new Error(MERGE_LIVE_MESSAGE);
+		const events = wrapList(options.on);
+		const channels = wrapList(options.channel).map(normalizeChannel);
+		this.liveDeclarations.push({
+			events,
+			channels
+		});
+		if (options.throttle !== void 0) this.liveThrottle = options.throttle;
+		return this;
+	}
+	/**
+	* Build the channel listeners, ported from inertia-laravel's
+	* `HasLiveUpdates::liveListeners()` without event-class branches. Each
+	* channel gets the deduplicated events declared for it, in first-seen order.
+	*/
+	liveListeners() {
+		if (!this.liveDeclarations.some((declaration) => declaration.events.length > 0)) throw new Error("A live property must listen for at least one event. Pass the event to the [on] option.");
+		const listeners = /* @__PURE__ */ new Map();
+		this.liveDeclarations.forEach(({ events, channels }) => {
+			events.forEach((event) => {
+				if (channels.length === 0) throw new Error(`Unable to resolve the channels for the [${event}] event. Pass the [channel] option.`);
+				channels.forEach((channel) => {
+					const key = `${channel.type}:${channel.name}`;
+					const listener = listeners.get(key) ?? {
+						channel: { ...channel },
+						events: []
+					};
+					if (!listener.events.includes(event)) listener.events.push(event);
+					listeners.set(key, listener);
+				});
+			});
+		});
+		return [...listeners.values()];
+	}
+	/**
+	* Resolve the source: call it when it is a function, then await the result.
+	*/
+	async resolveSource() {
+		if (typeof this.source === "function") return this.source();
+		return this.source;
+	}
+	/**
+	* Scroll metadata for a resolved value: the configured object, or the
+	* configured function applied to `resolved`.
+	*
+	* @param resolved The resolved prop value.
+	*/
+	metadataFor(resolved) {
+		if (this.scrollMetadata === null) throw new TypeError(`Prop of kind "${this.kind}" has no scroll metadata.`);
+		return typeof this.scrollMetadata === "function" ? this.scrollMetadata(resolved) : this.scrollMetadata;
+	}
+	/**
+	* `true` when no append or prepend paths were recorded.
+	*/
+	mergesAtRoot() {
+		return this.appendPaths.length === 0 && this.prependPaths.length === 0;
+	}
+	/**
+	* Record `path.matchOn` as a match-on path when `matchOn` is given.
+	*
+	* @param path The append/prepend path.
+	* @param matchOn Field to dedupe on.
+	*/
+	recordMatchOn(path, matchOn) {
+		if (matchOn) this.matchOnPaths.push(`${path}.${matchOn}`);
+	}
+};
+//#endregion
+//#region src/core/props.ts
+/**
+* Throw a `TypeError` unless `fn` is callable.
+*
+* @param name Constructor name, for the error message.
+* @param fn Value that must be a function.
+*/
+function assertCallable(name, fn) {
+	if (typeof fn !== "function") throw new TypeError(`${name}() expects a function, received ${typeof fn}.`);
+}
+/**
+* Throw a `TypeError` when a merge constructor received extra arguments
+* (the 2.x `merge(value, matchOn)` form), so migrating callers fail loudly
+* instead of silently losing their dedupe key.
+*
+* @param name Constructor name, for the error message.
+* @param extra Arguments passed after the value.
+*/
+function assertNoMatchOnArgument(name, extra) {
+	if (extra.length > 0) throw new TypeError(`${name}() takes a single argument; use ${name}(value).matchOn(...) to dedupe merged items.`);
+}
+/**
+* An optional prop: omitted from the first load, resolved when requested.
+*
+* @param fn Producer called (and awaited) when the prop is requested.
+*/
+function optional(fn) {
+	assertCallable("optional", fn);
+	const prop = new PropDescriptor("optional", fn);
+	prop.ignoreFirstLoad = true;
+	return prop;
+}
+/**
+* A deferred prop: omitted from the first load and fetched by the client in
+* a follow-up request with the rest of its group.
+*
+* @param fn Producer called (and awaited) on the follow-up request.
+* @param group Load group; props sharing a group are fetched together.
+*/
+function defer(fn, group = "default") {
+	assertCallable("defer", fn);
+	const prop = new PropDescriptor("defer", fn);
+	prop.ignoreFirstLoad = true;
+	return prop.defer(group);
+}
+/**
+* An always prop: included on every response, even partial reloads that do
+* not request it.
+*
+* @param value Plain value or producer.
+*/
+function always(value) {
+	const prop = new PropDescriptor("always", value);
+	prop.isAlways = true;
+	return prop;
+}
+/**
+* A live prop: its value is resolved like an always prop's source and the
+* client refreshes it when one of the given events arrives.
+*
+* @param value Plain value or producer.
+* @param options Events, channels and optional throttle.
+*/
+function live(value, options) {
+	return new PropDescriptor("live", value).live(options);
+}
+/**
+* A merge prop: the client appends it to its existing value at the root.
+* Throws a `TypeError` when given a second argument (the 2.x `matchOn`
+* form); chain `.matchOn()` instead.
+*
+* @param value Plain value or producer.
+* @param extra Rejected; present only to catch the 2.x call form.
+*/
+function merge(value, ...extra) {
+	assertNoMatchOnArgument("merge", extra);
+	return new PropDescriptor("merge", value).merge();
+}
+/**
+* A deep-merge prop: the client recursively merges it into its existing value.
+* Throws a `TypeError` when given a second argument (the 2.x `matchOn`
+* form); chain `.matchOn()` instead.
+*
+* @param value Plain value or producer.
+* @param extra Rejected; present only to catch the 2.x call form.
+*/
+function deepMerge(value, ...extra) {
+	assertNoMatchOnArgument("deepMerge", extra);
+	return new PropDescriptor("merge", value).deepMerge();
+}
+/**
+* A once prop: resolved once and cached by the client across visits.
+*
+* @param fn Producer called (and awaited) when the client lacks the value.
+*/
+function once(fn) {
+	assertCallable("once", fn);
+	return new PropDescriptor("once", fn).once();
+}
+/**
+* An infinite-scroll prop: merged at its wrapper key and carrying
+* pagination metadata.
+*
+* @param fn Producer called (and awaited) for each page.
+* @param options Wrapper key (default `'data'`) and pagination metadata.
+*/
+function scroll(fn, options) {
+	assertCallable("scroll", fn);
+	if (options?.metadata === void 0 || options.metadata === null) throw new TypeError("scroll() requires options.metadata.");
+	const prop = new PropDescriptor("scroll", fn).merge();
+	prop.isScroll = true;
+	prop.wrapper = options.wrapper ?? "data";
+	prop.scrollMetadata = options.metadata;
+	return prop;
+}
+/**
+* Type guard: `true` when `value` is a {@link PropDescriptor}.
+*
+* @param value Value to test.
+*/
+function isPropDescriptor(value) {
+	return value instanceof PropDescriptor;
+}
+//#endregion
+//#region src/core/dot-props.ts
+/**
+* Defines `key` on `container` as an own data property, so `__proto__` never reaches the setter.
+*
+* @param container Object to write into.
+* @param key Own key to define.
+* @param value Value to store.
+*/
+function defineOwn(container, key, value) {
+	Object.defineProperty(container, key, {
+		value,
+		enumerable: true,
+		writable: true,
+		configurable: true
+	});
+}
+/**
+* Calls and awaits `value` when it is a bare function; returns anything else unchanged.
+*
+* @param value Prop value or closure.
+*/
+async function resolveClosure(value) {
+	if (typeof value === "function" && !isPropDescriptor(value)) return await value();
+	return value;
+}
+/**
+* Shallow copy of `value` when it is a plain object or array, otherwise a fresh empty object.
+*
+* @param value Segment value to copy for writing.
+*/
+function copyForWrite(value) {
+	if (Array.isArray(value)) return [...value];
+	if (value !== null && typeof value === "object" && !isPropDescriptor(value)) {
+		const proto = Object.getPrototypeOf(value);
+		if (proto === Object.prototype || proto === null) return { ...value };
+	}
+	return {};
+}
+/**
+* Sets `value` at the dot-notation `key` inside `result`, resolving closures along the way.
+*
+* @param result Props object being built; written in place.
+* @param key Dot-notation key.
+* @param value Already-resolved value to set.
+*/
+async function setDotted(result, key, value) {
+	const segments = key.split(".");
+	const last = segments.pop();
+	defineOwn(await segments.reduce(async (parentPromise, segment) => {
+		const parent = await parentPromise;
+		const next = copyForWrite(await resolveClosure(Object.hasOwn(parent, segment) ? parent[segment] : void 0));
+		defineOwn(parent, segment, next);
+		return next;
+	}, Promise.resolve(result)), last, value);
+}
+/**
+* Unpacks top-level dot-notation keys into nested objects, like `Arr::set`.
+*
+* Bare functions along the intermediate segments, and at the dotted key itself, are called and
+* awaited first. Non-object segments are replaced by fresh objects. Prop descriptors are left as
+* values for the resolver. The input and the nested objects it holds are never mutated.
+*
+* @param props Page props that may contain dotted keys.
+*/
+async function unpackDotProps(props) {
+	return Object.keys(props).filter((key) => key.includes(".")).reduce(async (resultPromise, key) => {
+		const result = await resultPromise;
+		const value = await resolveClosure(props[key]);
+		delete result[key];
+		await setDotted(result, key, value);
+		return result;
+	}, Promise.resolve({ ...props }));
+}
+//#endregion
+//#region src/core/partial-filter.ts
+/**
+* `true` when `path` equals `parent` or lies in its dot-notation subtree.
+*
+* @param path Dot-notation prop path to test.
+* @param parent Dot-notation path that may contain `path`.
+*/
+function pathIsSameOrDescendant(path, parent) {
+	return path === parent || path.startsWith(`${parent}.`);
+}
+/**
+* `true` when `path` matches an `only` entry or is a descendant of one.
+*
+* @param path Dot-notation prop path to test.
+* @param only Requested partial-reload `only` paths.
+*/
+function matchesOnly(path, only) {
+	return only.some((onlyPath) => pathIsSameOrDescendant(path, onlyPath));
+}
+/**
+* `true` when `path` is a strict ancestor of an `only` entry.
+*
+* @param path Dot-notation prop path to test.
+* @param only Requested partial-reload `only` paths.
+*/
+function leadsToOnly(path, only) {
+	return only.some((onlyPath) => onlyPath.startsWith(`${path}.`));
+}
+/**
+* `true` when `path` equals an `except` entry, is a descendant of one, or is
+* an ancestor of one. Matching ancestors mirrors the reference Node server,
+* whose flat filter drops a top-level key whenever any `except` entry lives
+* under it; inertia-laravel keeps the ancestor and drops only the child.
+*
+* @param path Dot-notation prop path to test.
+* @param except Requested partial-reload `except` paths.
+*/
+function matchesExcept(path, except) {
+	return except.some((exceptPath) => pathIsSameOrDescendant(path, exceptPath) || pathIsSameOrDescendant(exceptPath, path));
+}
+//#endregion
+//#region src/core/props-resolver.ts
+/**
+* `true` for arrays and for objects whose prototype is `Object.prototype` or `null`.
+*
+* @param value Value to test.
+*/
+function isPlainObjectOrArray(value) {
+	if (Array.isArray(value)) return true;
+	if (value === null || typeof value !== "object") return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+/**
+* Normalize a partial header list: empty entries are dropped and an empty list becomes `null`.
+*
+* @param list Parsed header list, or `null` when absent.
+*/
+function normalizeList(list) {
+	const entries = (list ?? []).filter((entry) => entry !== "");
+	return entries.length > 0 ? entries : null;
+}
+/**
+* Default rescue hook: log the rescued error with the prop's path.
+*
+* @param error The thrown value.
+* @param path Dot path of the rescued prop.
+*/
+function reportRescuedError(error, path) {
+	console.error(`Inertia prop '${path}' failed to resolve and was rescued.`, error);
+}
+/**
+* Report a failure of a custom rescue hook through the default reporter:
+* the original rescued error, then the hook's own error.
+*
+* @param hookError The value the hook threw or rejected with.
+* @param error The rescued error the hook was given.
+* @param path Dot path of the rescued prop.
+*/
+function reportHookFailure(hookError, error, path) {
+	reportRescuedError(error, path);
+	console.error(`Inertia onRescue hook failed while reporting prop '${path}'.`, hookError);
+}
+/**
+* Marker returned by a settled entry that is left out of its parent node.
+*/
+const EXCLUDED = Symbol("excluded");
+/**
+* Every {@link Rescued} wrapper created by {@link rescued}.
+*/
+const rescuedMarkers = /* @__PURE__ */ new WeakSet();
+/**
+* Wrap a rescued error.
+*
+* @param error The thrown value.
+*/
+function rescued(error) {
+	const marker = { error };
+	rescuedMarkers.add(marker);
+	return marker;
+}
+/**
+* `true` when `value` is a wrapper created by {@link rescued}.
+*
+* @param value A resolved value.
+*/
+function isRescued(value) {
+	return typeof value === "object" && value !== null && rescuedMarkers.has(value);
+}
+/**
+* `true` when a prop must be resolved asynchronously: a descriptor, a
+* function, or a thenable. Anything else is copied as is.
+*
+* @param prop The prop as found in its parent node.
+*/
+function needsResolution(prop) {
+	if (typeof prop === "function") return true;
+	if (prop === null || typeof prop !== "object") return false;
+	return isPropDescriptor(prop) || typeof prop.then === "function";
+}
+/**
+* Swallow a rejection on a started resolution that may never be awaited
+* because an earlier sibling failed; the awaited copy still rejects.
+*/
+function ignoreRejection() {}
+/**
+* Write a settled entry into the node being built, skipping excluded entries.
+* Object keys are written as own data properties, so `__proto__` never
+* reaches the prototype setter.
+*
+* @param result Node being built; written in place.
+* @param key Key of the entry.
+* @param outcome Settled value, or {@link EXCLUDED}.
+*/
+function writeEntry(result, key, outcome) {
+	if (outcome === EXCLUDED) return;
+	if (Array.isArray(result)) result.push(outcome);
+	else if (key === "__proto__") Object.defineProperty(result, key, {
+		value: outcome,
+		enumerable: true,
+		writable: true,
+		configurable: true
+	});
+	else result[key] = outcome;
+}
+/**
+* Resolves shared and page props for one response, applying partial-reload
+* filtering and initial-load exclusion and collecting page metadata. Port of
+* inertia-laravel's `PropsResolver`. Use one instance per response: the
+* instance accumulates metadata, so {@link PropsResolver.resolve} throws when
+* called a second time. The resolver only reads descriptors, never writes
+* them. Metadata maps keyed by user input (`deferredProps`, `scrollProps`,
+* `onceProps`) have a null prototype, so any key, `__proto__` included, is
+* stored as an own property.
+*/
+var PropsResolver = class {
+	request;
+	component;
+	onRescue;
+	isPartial;
+	isInertia;
+	only;
+	except;
+	sharedPropKeys = [];
+	mergeProps = [];
+	prependProps = [];
+	deepMergeProps = [];
+	matchPropsOn = [];
+	deferredProps = Object.create(null);
+	rescuedProps = [];
+	scrollProps = Object.create(null);
+	onceProps = Object.create(null);
+	liveProps = Object.create(null);
+	used = false;
+	/**
+	* Create a resolver for one request and component.
+	*
+	* @param request Normalized Inertia request state.
+	* @param component Component being rendered.
+	* @param onRescue Hook called when a rescued prop throws.
+	*/
+	constructor(request, component, onRescue) {
+		this.request = request;
+		this.component = component;
+		this.onRescue = onRescue ?? reportRescuedError;
+		this.isPartial = request.partialComponent === component;
+		this.isInertia = request.isInertia;
+		this.only = normalizeList(request.partialOnly);
+		this.except = normalizeList(request.partialExcept);
+	}
+	/**
+	* Resolve the given shared and page props, collecting their metadata.
+	*
+	* @param shared Already-evaluated shared props.
+	* @param props Page props; these win over shared props on collision.
+	*/
+	async resolve(shared, props) {
+		this.markUsed();
+		const combined = {
+			...this.resolveSharedProps(shared),
+			...props
+		};
+		return {
+			props: await this.walk(await unpackDotProps(combined), "", false),
+			metadata: this.buildMetadata()
+		};
+	}
+	/**
+	* Resolve props for a socket broadcast payload: every prop is resolved, with
+	* no partial filtering, once/defer exclusion, metadata or dotted-key
+	* unpacking. Siblings resolve concurrently and keep insertion order; rescued
+	* props are reported and omitted; plain objects and arrays are recursed into.
+	*
+	* @param props Props to resolve.
+	*/
+	async resolveBroadcast(props) {
+		this.markUsed();
+		return await this.broadcastNode(props, "");
+	}
+	/**
+	* Fail when this resolver has already been used; otherwise mark it used.
+	*/
+	markUsed() {
+		if (this.used) throw new Error("PropsResolver.resolve() was already called on this instance; create one resolver per response.");
+		this.used = true;
+	}
+	/**
+	* Resolve one level of a broadcast payload.
+	*
+	* @param node Plain object or array whose entries are resolved.
+	* @param prefix Dot path of the node, empty at the root.
+	*/
+	async broadcastNode(node, prefix) {
+		const keys = Object.keys(node);
+		const values = await Promise.all(keys.map(async (key) => this.broadcastEntry(node[key], prefix === "" ? key : `${prefix}.${key}`)));
+		const result = Array.isArray(node) ? [] : {};
+		keys.forEach((key, index) => {
+			writeEntry(result, key, values[index]);
+		});
+		return result;
+	}
+	/**
+	* Resolve a single broadcast entry, unwrapping one level of returned descriptor.
+	*
+	* @param prop The entry's raw value.
+	* @param path Dot path of the entry.
+	*/
+	async broadcastEntry(prop, path) {
+		let value = await this.resolveValue(prop);
+		if (isRescued(value)) return this.rescue(value.error, path);
+		if (value !== prop && this.isPropType(value)) {
+			value = await this.resolveValue(value);
+			if (isRescued(value)) return this.rescue(value.error, path);
+		}
+		return isPlainObjectOrArray(value) ? this.broadcastNode(value, path) : value;
+	}
+	/**
+	* Record the top-level keys of shared props (the segment before the first
+	* `.` for dot-notation keys), deduplicated in first-seen order.
+	*
+	* @param shared Already-evaluated shared props.
+	*/
+	resolveSharedProps(shared) {
+		Object.keys(shared).forEach((key) => {
+			const [topLevel = key] = key.split(".", 1);
+			if (!this.sharedPropKeys.includes(topLevel)) this.sharedPropKeys.push(topLevel);
+		});
+		return shared;
+	}
+	/**
+	* Build the non-empty metadata entries for the page response, in protocol order.
+	*/
+	buildMetadata() {
+		const entries = [
+			["sharedProps", this.sharedPropKeys],
+			["mergeProps", this.mergeProps],
+			["prependProps", this.prependProps],
+			["deepMergeProps", this.deepMergeProps],
+			["matchPropsOn", this.matchPropsOn],
+			["deferredProps", this.deferredProps],
+			["rescuedProps", this.rescuedProps],
+			["scrollProps", this.scrollProps],
+			["onceProps", this.onceProps],
+			["liveProps", this.liveProps]
+		];
+		return Object.fromEntries(entries.filter(([, value]) => Object.keys(value).length > 0));
+	}
+	/**
+	* Recursively resolve a props node, collecting metadata along the way.
+	* Every included entry that needs resolving is started in insertion order
+	* before any is awaited, so siblings resolve concurrently; each entry is
+	* then settled in insertion order (rescue, one-level unwrap, metadata,
+	* recursion), keeping output key order and metadata order deterministic.
+	* Plain values are copied synchronously, so a node without closures or
+	* descriptors comes back without a promise. Arrays come back as arrays
+	* with excluded entries dropped, so later index-based `except`/`reset`
+	* paths shift down; objects come back as fresh plain objects. When the
+	* original prop was not itself a plain object or array (e.g. a closure
+	* that returned one), its children bypass partial filtering.
+	*
+	* @param node Plain object or array to walk.
+	* @param prefix Dot path of `node`, or `''` at the root.
+	* @param parentWasResolved Whether an ancestor was produced by resolving a closure or descriptor.
+	*/
+	walk(node, prefix, parentWasResolved) {
+		const entries = this.startEntries(node, prefix, parentWasResolved);
+		const result = Array.isArray(node) ? [] : {};
+		for (let index = 0; index < entries.length; index += 1) {
+			const entry = entries[index];
+			const outcome = this.settleEntry(entry, parentWasResolved);
+			if (outcome instanceof Promise) return this.finishWalk(entries, index, outcome, result, parentWasResolved);
+			writeEntry(result, entry.key, outcome);
+		}
+		return result;
+	}
+	/**
+	* Continue a walk asynchronously from the first entry whose outcome is pending.
+	*
+	* @param entries Started entries of the node.
+	* @param index Index of the pending entry.
+	* @param pending Outcome of the entry at `index`.
+	* @param result Node being built; written in place.
+	* @param parentWasResolved Whether an ancestor was produced by resolving a closure or descriptor.
+	*/
+	async finishWalk(entries, index, pending, result, parentWasResolved) {
+		writeEntry(result, entries[index].key, await pending);
+		for (let next = index + 1; next < entries.length; next += 1) {
+			const entry = entries[next];
+			const outcome = this.settleEntry(entry, parentWasResolved);
+			writeEntry(result, entry.key, outcome instanceof Promise ? await outcome : outcome);
+		}
+		return result;
+	}
+	/**
+	* Run the synchronous pre-resolve checks (partial filter, initial-load
+	* exclusion) over a node's entries in insertion order and start resolving
+	* every included entry that needs it.
+	*
+	* @param node Plain object or array to walk.
+	* @param prefix Dot path of `node`, or `''` at the root.
+	* @param parentWasResolved Whether an ancestor was produced by resolving a closure or descriptor.
+	*/
+	startEntries(node, prefix, parentWasResolved) {
+		const entries = [];
+		const visit = (prop, key) => {
+			const path = prefix === "" ? key : `${prefix}.${key}`;
+			if (this.shouldIncludeInPartialResponse(prop, path, parentWasResolved)) entries.push(this.startEntry(key, path, prop));
+		};
+		if (Array.isArray(node)) node.forEach((prop, index) => visit(prop, String(index)));
+		else Object.keys(node).forEach((key) => visit(node[key], key));
+		return entries;
+	}
+	/**
+	* Classify one included entry: excluded from the initial load, pending
+	* resolution (started now), or a plain value copied as is.
+	*
+	* @param key Key of the entry in its parent node.
+	* @param path Dot path of the entry.
+	* @param prop The prop as found in its parent node.
+	*/
+	startEntry(key, path, prop) {
+		if (!this.isPartial && this.isExcludedFromInitialResponse(prop, path)) return {
+			key,
+			path,
+			prop,
+			excluded: true,
+			pending: null
+		};
+		if (needsResolution(prop)) {
+			const pending = this.resolveValue(prop);
+			pending.catch(ignoreRejection);
+			return {
+				key,
+				path,
+				prop,
+				excluded: false,
+				pending
+			};
+		}
+		return {
+			key,
+			path,
+			prop,
+			excluded: false,
+			pending: null
+		};
+	}
+	/**
+	* Finish one started entry in insertion order. Returns the value to write,
+	* {@link EXCLUDED}, or a promise of either when the entry needs awaiting.
+	*
+	* @param entry The started entry.
+	* @param parentWasResolved Whether an ancestor was produced by resolving a closure or descriptor.
+	*/
+	settleEntry(entry, parentWasResolved) {
+		if (entry.excluded) {
+			this.collectExclusionMetadata(entry.prop, entry.path);
+			return EXCLUDED;
+		}
+		if (entry.pending !== null) return this.settleResolved(entry, entry.pending, parentWasResolved);
+		return this.include(entry.prop, entry.prop, entry.path, parentWasResolved);
+	}
+	/**
+	* Await a started resolution, then apply rescue, the one-level descriptor
+	* unwrap (with its own initial-load exclusion) and inclusion.
+	*
+	* @param entry The started entry.
+	* @param pending The entry's resolution.
+	* @param parentWasResolved Whether an ancestor was produced by resolving a closure or descriptor.
+	*/
+	async settleResolved(entry, pending, parentWasResolved) {
+		const { path } = entry;
+		let current = entry.prop;
+		let value = await pending;
+		if (isRescued(value)) return this.rescue(value.error, path);
+		if (value !== current && this.isPropType(value)) {
+			current = value;
+			if (!this.isPartial && this.isExcludedFromInitialResponse(current, path)) {
+				this.collectExclusionMetadata(current, path);
+				return EXCLUDED;
+			}
+			value = await this.resolveValue(current);
+			if (isRescued(value)) return this.rescue(value.error, path);
+		}
+		return this.include(current, value, path, parentWasResolved);
+	}
+	/**
+	* Include a resolved prop: check scroll shape, collect metadata, and walk
+	* into plain objects and arrays.
+	*
+	* @param prop The prop that produced `value`.
+	* @param value The prop's resolved value.
+	* @param path Dot path of the prop.
+	* @param parentWasResolved Whether an ancestor was produced by resolving a closure or descriptor.
+	*/
+	include(prop, value, path, parentWasResolved) {
+		this.assertScrollShape(prop, path, value);
+		this.collectMetadata(prop, path, value, parentWasResolved);
+		if (isPlainObjectOrArray(value)) return this.walk(value, path, parentWasResolved || !isPlainObjectOrArray(prop));
+		return value;
+	}
+	/**
+	* Determine if a prop belongs in the response: always on a full visit;
+	* on a partial reload, when it bypasses filtering or its path matches the request.
+	*
+	* @param prop The prop being considered.
+	* @param path Dot path of the prop.
+	* @param parentWasResolved Whether an ancestor was produced by resolving a closure or descriptor.
+	*/
+	shouldIncludeInPartialResponse(prop, path, parentWasResolved) {
+		if (!this.isPartial || this.bypassesPartialFiltering(prop, parentWasResolved)) return true;
+		return this.pathMatchesPartialRequest(path);
+	}
+	/**
+	* Determine if a prop is resolved independently of partial filters:
+	* always props, and children of already-resolved values.
+	*
+	* @param prop The prop being considered.
+	* @param parentWasResolved Whether an ancestor was produced by resolving a closure or descriptor.
+	*/
+	bypassesPartialFiltering(prop, parentWasResolved) {
+		return isPropDescriptor(prop) && prop.isAlways || parentWasResolved;
+	}
+	/**
+	* Determine if the path matches the partial request using bidirectional
+	* prefix matching on both the only list and the except list.
+	*
+	* @param path Dot path of the prop.
+	*/
+	pathMatchesPartialRequest(path) {
+		if (this.only !== null && !matchesOnly(path, this.only) && !leadsToOnly(path, this.only)) return false;
+		if (this.except !== null && matchesExcept(path, this.except)) return false;
+		return true;
+	}
+	/**
+	* Determine if a prop is excluded from the initial page response: an
+	* optional or deferred descriptor, or a once-prop the client already holds.
+	*
+	* @param prop The prop being considered.
+	* @param path Dot path of the prop.
+	*/
+	isExcludedFromInitialResponse(prop, path) {
+		if (!isPropDescriptor(prop)) return false;
+		return prop.ignoreFirstLoad || prop.defers || this.isInertia && this.wasAlreadyLoadedByClient(prop, path);
+	}
+	/**
+	* Collect the metadata of a prop excluded from the initial response
+	* according to why it was excluded.
+	*
+	* @param prop The descriptor being excluded.
+	* @param path Dot path of the prop.
+	*/
+	collectExclusionMetadata(prop, path) {
+		if (prop.isLive) this.collectLiveMetadata(path, prop, false);
+		if (prop.ignoreFirstLoad) this.collectIgnoredPropMetadata(prop, path);
+		else if (prop.defers) this.collectDeferredExclusionMetadata(prop, path);
+		else this.collectOnceMetadata(path, prop);
+	}
+	/**
+	* Collect the deferred, merge and once metadata of an excluded
+	* first-load-ignored prop (optional, defer).
+	*
+	* @param prop The descriptor being excluded.
+	* @param path Dot path of the prop.
+	*/
+	collectIgnoredPropMetadata(prop, path) {
+		if (prop.defers && !this.wasAlreadyLoadedByClient(prop, path)) this.collectDeferredPropMetadata(path, prop);
+		if (prop.merges) this.collectMergeableMetadata(path, prop, true);
+		if (prop.resolvesOnce) this.collectOnceMetadata(path, prop);
+	}
+	/**
+	* Collect the deferred-group and merge metadata of an excluded deferred prop.
+	*
+	* @param prop The descriptor being excluded.
+	* @param path Dot path of the prop.
+	*/
+	collectDeferredExclusionMetadata(prop, path) {
+		this.collectDeferredPropMetadata(path, prop);
+		if (prop.merges) this.collectMergeableMetadata(path, prop, true);
+	}
+	/**
+	* Determine if a once-prop has already been loaded by the client: it
+	* resolves once, is not forced fresh, and its key (or path) is listed in
+	* the client's except-once header.
+	*
+	* @param prop The descriptor being considered.
+	* @param path Dot path of the prop.
+	*/
+	wasAlreadyLoadedByClient(prop, path) {
+		return prop.resolvesOnce && !prop.isFresh && this.request.exceptOnceProps.includes(prop.onceKey ?? path);
+	}
+	/**
+	* Resolve a single prop value: a descriptor resolves its source, a bare
+	* function is called, and the result is awaited; anything else passes
+	* through. An error thrown by a rescuable descriptor comes back wrapped in
+	* {@link Rescued}; any other error rejects.
+	*
+	* @param prop The prop to resolve.
+	*/
+	async resolveValue(prop) {
+		try {
+			if (isPropDescriptor(prop)) return await prop.resolveSource();
+			if (typeof prop === "function") return await prop();
+			return await prop;
+		} catch (error) {
+			if (isPropDescriptor(prop) && prop.rescues) return rescued(error);
+			throw error;
+		}
+	}
+	/**
+	* Throw when a scroll prop did not resolve to a plain object holding its
+	* wrapper key as an own property.
+	*
+	* @param prop The prop being included.
+	* @param path Dot path of the prop.
+	* @param resolved The prop's resolved value.
+	*/
+	assertScrollShape(prop, path, resolved) {
+		if (!isPropDescriptor(prop) || !prop.isScroll) return;
+		if (Array.isArray(resolved) || !isPlainObjectOrArray(resolved) || !Object.hasOwn(resolved, prop.wrapper)) throw new TypeError(`Scroll prop '${path}' must resolve to an object with a '${prop.wrapper}' key`);
+	}
+	/**
+	* Record a rescued prop: report the error, add its path to `rescuedProps`
+	* and omit it from the response.
+	*
+	* @param error The thrown value.
+	* @param path Dot path of the prop.
+	*/
+	rescue(error, path) {
+		this.reportRescue(error, path);
+		this.rescuedProps.push(path);
+		return EXCLUDED;
+	}
+	/**
+	* Call the rescue hook with the failure contained: a synchronous throw or
+	* a rejected returned thenable is logged through the default reporter and
+	* never propagates or surfaces as an unhandled rejection.
+	*
+	* @param error The thrown value.
+	* @param path Dot path of the prop.
+	*/
+	reportRescue(error, path) {
+		const hook = this.onRescue;
+		try {
+			const result = hook(error, path);
+			if (result !== null && typeof result === "object" && typeof result.then === "function") Promise.resolve(result).catch((hookError) => reportHookFailure(hookError, error, path));
+		} catch (hookError) {
+			reportHookFailure(hookError, error, path);
+		}
+	}
+	/**
+	* Determine if the value is a prop type that needs further filtering or
+	* metadata collection.
+	*
+	* @param value The resolved value.
+	*/
+	isPropType(value) {
+		return isPropDescriptor(value);
+	}
+	/**
+	* Collect metadata for a prop that will be included in the response.
+	*
+	* @param prop The prop being included.
+	* @param path Dot path of the prop.
+	* @param resolved The prop's resolved value.
+	* @param parentWasResolved Whether an ancestor was produced by resolving a closure or descriptor.
+	*/
+	collectMetadata(prop, path, resolved, parentWasResolved) {
+		if (!isPropDescriptor(prop)) return;
+		if (prop.merges) this.collectMergeableMetadata(path, prop, false);
+		if (prop.isScroll) this.collectScrollMetadata(path, prop, resolved);
+		if (prop.resolvesOnce) this.collectOnceMetadata(path, prop);
+		if (prop.isLive) this.collectLiveMetadata(path, prop, parentWasResolved);
+	}
+	/**
+	* Collect the listener manifest of a live prop, unless a partial request
+	* filters it out. Listener errors are not rescued.
+	*
+	* @param path Dot path of the prop.
+	* @param prop The live descriptor.
+	* @param parentWasResolved Whether an ancestor was produced by resolving a closure or descriptor.
+	*/
+	collectLiveMetadata(path, prop, parentWasResolved) {
+		if (this.isPartial && !this.bypassesPartialFiltering(prop, parentWasResolved) && !this.isIncludedInPartialMetadata(path)) return;
+		this.liveProps[path] = {
+			listeners: prop.liveListeners(),
+			...prop.liveThrottle !== null ? { throttle: prop.liveThrottle } : {}
+		};
+	}
+	/**
+	* Collect the deferred prop under its group.
+	*
+	* @param path Dot path of the prop.
+	* @param prop The deferred descriptor.
+	*/
+	collectDeferredPropMetadata(path, prop) {
+		const group = this.deferredProps[prop.group] ?? [];
+		group.push(path);
+		this.deferredProps[prop.group] = group;
+	}
+	/**
+	* Collect the merge strategy for a mergeable prop, unless the client asked
+	* to reset it or a partial request filters it out.
+	*
+	* @param path Dot path of the prop.
+	* @param prop The mergeable descriptor.
+	* @param excluded Whether the prop is being excluded from this response rather than resolved.
+	*/
+	collectMergeableMetadata(path, prop, excluded) {
+		if (this.request.resetKeys?.includes(path)) return;
+		if (this.isPartial && !this.isIncludedInPartialMetadata(path)) return;
+		const layout = this.mergeLayoutFor(prop, excluded);
+		if (prop.deep) this.deepMergeProps.push(path);
+		else if (layout.appendsAtRoot) this.mergeProps.push(path);
+		else if (layout.prependsAtRoot) this.prependProps.push(path);
+		else {
+			this.mergeProps.push(...layout.appendPaths.map((appendPath) => `${path}.${appendPath}`));
+			this.prependProps.push(...layout.prependPaths.map((prependPath) => `${path}.${prependPath}`));
+		}
+		this.matchPropsOn.push(...prop.matchOnPaths.map((matchOn) => `${path}.${matchOn}`));
+	}
+	/**
+	* The merge layout of a descriptor for this request, read without writing
+	* to the descriptor. A scroll descriptor derives its layout per request:
+	* a root append while it is excluded as deferred, otherwise its wrapper key
+	* appended or prepended according to the client's merge intent (the
+	* read-only equivalent of `ScrollProp::configureMergeIntent`).
+	*
+	* @param prop The mergeable descriptor.
+	* @param excluded Whether the prop is being excluded from this response rather than resolved.
+	*/
+	mergeLayoutFor(prop, excluded) {
+		if (!prop.isScroll) return prop;
+		if (excluded) return {
+			appendsAtRoot: true,
+			prependsAtRoot: false,
+			appendPaths: [],
+			prependPaths: []
+		};
+		const prepends = this.request.mergeIntent === "prepend";
+		return {
+			appendsAtRoot: false,
+			prependsAtRoot: false,
+			appendPaths: prepends ? [] : [prop.wrapper],
+			prependPaths: prepends ? [prop.wrapper] : []
+		};
+	}
+	/**
+	* Determine if the path should contribute metadata during a partial request.
+	*
+	* @param path Dot path of the prop.
+	*/
+	isIncludedInPartialMetadata(path) {
+		if (this.only !== null && !matchesOnly(path, this.only)) return false;
+		if (this.except !== null && matchesExcept(path, this.except)) return false;
+		return true;
+	}
+	/**
+	* Collect scroll pagination metadata, flagged for reset when the client
+	* asked to reset the prop.
+	*
+	* @param path Dot path of the prop.
+	* @param prop The scroll descriptor.
+	* @param resolved The prop's resolved value.
+	*/
+	collectScrollMetadata(path, prop, resolved) {
+		this.scrollProps[path] = {
+			...prop.metadataFor(resolved),
+			reset: this.request.resetKeys?.includes(path) ?? false
+		};
+	}
+	/**
+	* Collect once-prop metadata under its custom key (or path), unless a
+	* partial request filters it out.
+	*
+	* @param path Dot path of the prop.
+	* @param prop The once descriptor.
+	*/
+	collectOnceMetadata(path, prop) {
+		if (!prop.resolvesOnce) return;
+		if (this.isPartial && !this.isIncludedInPartialMetadata(path)) return;
+		this.onceProps[prop.onceKey ?? path] = {
+			prop: path,
+			expiresAt: prop.expiresAt()
+		};
+	}
+};
+/**
+* Resolve shared and page props for one response.
+*
+* @param input Props, shared props, component, request state and rescue hook.
+*/
+async function resolveProps(input) {
+	return new PropsResolver(input.request, input.component, input.onRescue).resolve(input.shared, input.props);
+}
+//#endregion
+//#region src/core/broadcast.ts
+/**
+* Request info for a broadcast: not an Inertia request, nothing partial, nothing already loaded.
+*/
+const EMPTY_REQUEST = Object.freeze({
+	isInertia: false,
+	version: null,
+	partialComponent: null,
+	partialOnly: null,
+	partialExcept: null,
+	errorBag: null,
+	resetKeys: null,
+	exceptOnceProps: [],
+	mergeIntent: "append",
+	isPrefetch: false,
+	socketId: null,
+	method: "GET",
+	url: "/"
+});
+/**
+* Resolve props for a socket broadcast payload. Every prop is resolved (no
+* partial filtering, no once/defer exclusion) and rescued props are omitted.
+*
+* @param props Props to resolve.
+* @param onRescue Hook called when a rescued prop throws.
+*/
+async function resolveBroadcastProps(props, onRescue) {
+	return new PropsResolver({
+		...EMPTY_REQUEST,
+		exceptOnceProps: []
+	}, "", onRescue).resolveBroadcast(props);
+}
+/**
+* Build the `{ __inertia: { props } }` envelope a socket server broadcasts.
+*
+* @param props Props to resolve.
+* @param onRescue Hook called when a rescued prop throws.
+*/
+async function broadcastProps(props, onRescue) {
+	return { __inertia: { props: await resolveBroadcastProps(props, onRescue) } };
+}
+//#endregion
+//#region src/core/cache.ts
+/**
+* Recursively normalize a value so equal-by-value inputs serialize identically:
+* object keys are sorted, `undefined` properties are dropped, and non-finite
+* numbers collapse to `null`.
+*
+* @param value Arbitrary JSON-shaped input.
+*/
+function canonicalize(value) {
+	if (value === null) return null;
+	if (typeof value !== "object") {
+		if (typeof value === "number" && !Number.isFinite(value)) return null;
+		return value;
+	}
+	if (Array.isArray(value)) return value.map(canonicalize);
+	const obj = value;
+	return Object.fromEntries(Object.keys(obj).sort().filter((key) => obj[key] !== void 0).map((key) => [key, canonicalize(obj[key])]));
+}
+/**
+* Stable JSON encoding: keys sorted recursively, undefined dropped, NaN/Inf
+* normalized. Two equal-by-value objects always produce the same string,
+* so they hash to the same cache key.
+*
+* @param value Arbitrary JSON-shaped input.
+*/
+function canonicalStringify(value) {
+	return JSON.stringify(canonicalize(value));
+}
+/**
+* Build the cache key for an SSR cache entry.
+*
+* Shape: `${prefix}:${version}:${component}:${sha256(props[+discriminator])}`
+*
+* Including `version` in the key namespace means a deploy that bumps the
+* asset version atomically retires every old key — no flush, no race.
+*
+* @param input Prefix, version, component, resolved props, optional discriminator.
+*/
+function computeSsrCacheKey(input) {
+	const versionPart = input.version ?? "_";
+	const propsHash = createHash("sha256").update(canonicalStringify(input.props)).update(input.discriminator ?? "").digest("hex").slice(0, 32);
+	return `${input.prefix}:${versionPart}:${input.component}:${propsHash}`;
+}
+//#endregion
+//#region src/core/errors.ts
+/**
+* Apply error-bag scoping to a flat errors object, matching the official
+* Inertia behavior. When `bag` is set, errors are namespaced under
+* `props.errors[bag]`. When `bag` is null, errors live at `props.errors`.
+*
+* @param errors Flat field-to-message map.
+* @param bag Optional error-bag name (e.g. `"createUser"`); null for top-level.
+*/
+function scopeErrors(errors, bag) {
+	if (bag) return { errors: { [bag]: errors } };
+	return { errors };
+}
+/**
+* Resolve the `errors` prop from validation error bags at read time. Port of
+* inertia-laravel `Middleware::resolveValidationErrors` (3.x).
+*
+* - No bags, or an empty map: `{}`.
+* - A `default` bag and an `errorBag` sent by the client: scoped to that name,
+*   `{ [errorBag]: bags.default }`.
+* - A `default` bag with no `errorBag`: the default bag flat, `bags.default`.
+* - No `default` bag: the bags map as-is, each key already a bag name.
+*
+* @param bags Error bags keyed by name, or null/undefined when none exist.
+* @param errorBag Bag name from the `X-Inertia-Error-Bag` request header, or null.
+*/
+function resolveValidationErrors(bags, errorBag) {
+	if (!bags || Object.keys(bags).length === 0) return {};
+	const defaultBag = bags.default;
+	if (defaultBag !== void 0) {
+		if (errorBag) return { [errorBag]: defaultBag };
+		return defaultBag;
+	}
+	return bags;
+}
+//#endregion
+//#region src/core/headers.ts
+/**
+* Canonical Inertia v3 protocol header names.
+*
+* The Inertia client sends these headers on every visit. The server uses
+* them to decide between a full HTML response and a JSON page response,
+* and to scope partial reloads.
+*/
+const INERTIA_HEADERS = {
+	inertia: "x-inertia",
+	version: "x-inertia-version",
+	partialComponent: "x-inertia-partial-component",
+	partialData: "x-inertia-partial-data",
+	partialExcept: "x-inertia-partial-except",
+	errorBag: "x-inertia-error-bag",
+	reset: "x-inertia-reset",
+	location: "x-inertia-location",
+	exceptOnceProps: "x-inertia-except-once-props",
+	mergeIntent: "x-inertia-infinite-scroll-merge-intent",
+	redirect: "x-inertia-redirect",
+	socketId: "x-socket-id"
+};
+/**
+* Headers browsers set on speculative (prefetch) requests. A request is a
+* prefetch when any of them equals `prefetch` (case-insensitive). Mirrors
+* Laravel's `Request::prefetch()`.
+*/
+const PREFETCH_HEADERS = [
+	"purpose",
+	"sec-purpose",
+	"x-moz"
+];
+/**
+* Read a header value as a single string, looking up the lowercase variant as
+* a fallback. Returns the first entry of an array value and `null` when the
+* header is absent.
+*
+* @param headers Raw header record from the HTTP layer.
+* @param name Header name to read.
+*/
+function readHeader(headers, name) {
+	const value = headers[name] ?? headers[name.toLowerCase()];
+	if (value === void 0 || value === null) return null;
+	if (Array.isArray(value)) return value[0] ?? null;
+	return value;
+}
+/**
+* Split a comma-separated header value into a trimmed, non-empty string list.
+* Returns `null` when the input is null or yields no entries.
+*
+* @param value Raw header value, or null when absent.
+*/
+function parseList(value) {
+	if (value === null) return null;
+	const parts = value.split(",").map((part) => part.trim()).filter((part) => part.length > 0);
+	return parts.length > 0 ? parts : null;
+}
+/**
+* Parse a request's headers into a normalized {@link InertiaRequestInfo}.
+*
+* @param input Headers, HTTP method, and request URL. Method is uppercased in
+*   the returned object; the URL is passed through unchanged.
+*/
+function parseInertiaRequest(input) {
+	const { headers } = input;
+	const inertia = readHeader(headers, INERTIA_HEADERS.inertia);
+	const version = readHeader(headers, INERTIA_HEADERS.version);
+	const partialComponent = readHeader(headers, INERTIA_HEADERS.partialComponent);
+	const partialOnly = parseList(readHeader(headers, INERTIA_HEADERS.partialData));
+	const partialExcept = parseList(readHeader(headers, INERTIA_HEADERS.partialExcept));
+	const errorBag = readHeader(headers, INERTIA_HEADERS.errorBag);
+	const resetKeys = parseList(readHeader(headers, INERTIA_HEADERS.reset));
+	const exceptOnceProps = parseList(readHeader(headers, INERTIA_HEADERS.exceptOnceProps)) ?? [];
+	const mergeIntent = readHeader(headers, INERTIA_HEADERS.mergeIntent) === "prepend" ? "prepend" : "append";
+	return {
+		isInertia: inertia === "true" || inertia === "1",
+		version,
+		partialComponent,
+		partialOnly,
+		partialExcept,
+		errorBag,
+		resetKeys,
+		exceptOnceProps,
+		mergeIntent,
+		isPrefetch: PREFETCH_HEADERS.some((name) => readHeader(headers, name)?.toLowerCase() === "prefetch"),
+		socketId: readHeader(headers, INERTIA_HEADERS.socketId),
+		method: input.method.toUpperCase(),
+		url: input.url
+	};
+}
+//#endregion
+//#region src/core/html.ts
+const HTML_ESCAPES = {
+	"&": "&amp;",
+	"<": "&lt;",
+	">": "&gt;",
+	"\"": "&quot;",
+	"'": "&#39;"
+};
+/**
+* Escape characters that would break out of a double-quoted HTML attribute.
+*
+* @param value Raw attribute value.
+*/
+function escapeHtmlAttribute(value) {
+	return value.replace(/[&<>"']/g, (ch) => HTML_ESCAPES[ch] ?? ch);
+}
+/**
+* Encode an Inertia page object for embedding inside a
+* `<script type="application/json" data-page="...">` tag — the Inertia v3
+* initial-page transport that the client reads via `getInitialPageFromDOM`.
+*
+* Every `<` is replaced with its JSON unicode escape so the payload cannot
+* terminate the surrounding `<\/script>` element or open an HTML comment. The
+* escape is transparent — JSON.parse decodes it back to `<`.
+*
+* @param page Resolved Inertia page object.
+*/
+function encodePageScript(page) {
+	return JSON.stringify(page).replace(/</g, "\\u003C");
+}
+/**
+* Minimal default HTML shell for use when no custom root view is provided.
+* Real apps should plug in a template engine (pug, ejs, react-dom/server,
+* etc.) and embed `encodePageScript(page)` themselves.
+*
+* The initial page object is emitted as a
+* `<script type="application/json" data-page="...">` tag, the Inertia v3
+* transport that the client reads on boot.
+*
+* @param input Page object plus optional title/head/rootId/scriptSrc/SSR markup
+*   — see {@link DefaultRootViewInput}.
+*/
+function renderDefaultHtml(input) {
+	const rootId = input.rootId ?? "app";
+	const title = input.title ?? "Inertia App";
+	const head = input.head ?? "";
+	const script = input.scriptSrc ? `<script type="module" src="${escapeHtmlAttribute(input.scriptSrc)}"><\/script>` : "";
+	let rootMarkup;
+	if (input.ssrFull) rootMarkup = input.ssrFull;
+	else {
+		const idAttr = escapeHtmlAttribute(rootId);
+		rootMarkup = `<div id="${idAttr}">${input.ssrBody ?? ""}</div>\n    ${`<script data-page="${idAttr}" type="application/json">${encodePageScript(input.page)}<\/script>`}`;
+	}
+	return `<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>${escapeHtmlAttribute(title)}</title>
+    ${head}
+  </head>
+  <body>
+    ${rootMarkup}
+    ${script}
+  </body>
+</html>`;
+}
+/** Default user-facing messages keyed by HTTP status, used when none is given. */
+const ERROR_STATUS_MESSAGES = {
+	400: "Bad Request",
+	401: "Unauthorized",
+	403: "Forbidden",
+	404: "Page Not Found",
+	409: "Conflict",
+	419: "Page Expired",
+	422: "Unprocessable Entity",
+	429: "Too Many Requests",
+	500: "Server Error",
+	502: "Bad Gateway",
+	503: "Service Unavailable",
+	504: "Gateway Timeout"
+};
+/**
+* Render a minimal, SPA-less standalone HTML error page. Used as the hard
+* fallback when no client `Error` component can be resolved (e.g. a plain
+* browser load, or an SSR/render failure on the Inertia path), so a user
+* never receives a raw JSON error or a blank page.
+*
+* @param input HTTP status plus an optional override message — see {@link ErrorPageInput}.
+*/
+function renderErrorPage(input) {
+	const { status } = input;
+	const message = input.message ?? ERROR_STATUS_MESSAGES[status] ?? "Something went wrong";
+	const safeStatus = escapeHtmlAttribute(String(status));
+	const safeMessage = escapeHtmlAttribute(message);
+	return `<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>${safeStatus} ${safeMessage}</title>
+    <style>
+      body { font-family: system-ui, sans-serif; display: flex; align-items: center; justify-content: center; min-height: 100vh; margin: 0; background: #f8f9fa; color: #212529; }
+      main { text-align: center; padding: 2rem; }
+      h1 { font-size: 4rem; margin: 0; font-weight: 600; }
+      p { font-size: 1.25rem; margin: 0.5rem 0 0; color: #6c757d; }
+    </style>
+  </head>
+  <body>
+    <main>
+      <h1>${safeStatus}</h1>
+      <p>${safeMessage}</p>
+    </main>
+  </body>
+</html>`;
+}
+//#endregion
+//#region src/core/page.ts
+/**
+* Whether flash data is worth emitting as a top-level page key. Nullish and
+* empty-object flash are dropped so the wire payload stays compact and
+* absent flash never surfaces a stray `flash: {}` to the client.
+*
+* @param flash Candidate flash value pulled from the session.
+*/
+function hasFlashData(flash) {
+	if (flash === null || flash === void 0) return false;
+	if (typeof flash === "object" && !Array.isArray(flash)) return Object.keys(flash).length > 0;
+	return true;
+}
+/**
+* Every {@link PropsMetadata} key, in protocol order. `createPage` copies only
+* these keys, so a widened metadata object cannot overwrite page fields.
+*/
+const METADATA_KEYS = [
+	"sharedProps",
+	"mergeProps",
+	"prependProps",
+	"deepMergeProps",
+	"matchPropsOn",
+	"deferredProps",
+	"rescuedProps",
+	"scrollProps",
+	"onceProps",
+	"liveProps"
+];
+/**
+* Whether a metadata value carries anything worth emitting: a non-empty array
+* or an object with at least one key.
+*
+* @param value Candidate metadata value from {@link PropsMetadata}.
+*/
+function hasMetadataEntries(value) {
+	if (Array.isArray(value)) return value.length > 0;
+	if (value !== null && typeof value === "object") return Object.keys(value).length > 0;
+	return false;
+}
+/**
+* Build a normalized Inertia v3 page object. `clearHistory`, `encryptHistory`
+* and `preserveFragment` default to `false` and are always present. Each
+* `metadata` key is copied onto the page only when non-empty so the JSON over
+* the wire stays compact. `flash` is emitted as a top-level key only when it
+* carries data (non-nullish, and a non-empty object when object-valued) —
+* mirroring inertia-laravel's `$flash ? ['flash' => $flash] : []`.
+*
+* @param input Required page fields plus the optional v3 extras.
+*/
+function createPage(input) {
+	const page = {
+		component: input.component,
+		props: input.props,
+		url: input.url,
+		version: input.version,
+		clearHistory: input.clearHistory ?? false,
+		encryptHistory: input.encryptHistory ?? false,
+		preserveFragment: input.preserveFragment ?? false
+	};
+	const { metadata } = input;
+	if (metadata) METADATA_KEYS.forEach((key) => {
+		if (hasMetadataEntries(metadata[key])) Object.assign(page, { [key]: metadata[key] });
+	});
+	if (hasFlashData(input.flash)) page.flash = input.flash;
+	return page;
+}
+//#endregion
+//#region src/core/redirects.ts
+/**
+* Status code Inertia uses for "soft" redirects after PUT/PATCH/DELETE so the
+* follow-up GET is forced to also be a GET on every browser.
+*/
+const INERTIA_REDIRECT_STATUS = 303;
+/**
+* Status code used for the `X-Inertia-Location` external redirect
+* mechanism. The client intercepts the 409 and performs a window.location
+* navigation rather than a fetch.
+*/
+const INERTIA_LOCATION_STATUS = 409;
+/**
+* Decide which status code to use for a redirect produced by an Inertia
+* request. After a non-GET/HEAD form submission (PUT, PATCH, DELETE or QUERY) the response must be 303
+* so the client's follow-up request becomes a GET.
+*
+* @param method HTTP method of the inbound request (case-insensitive).
+* @param fallback Status code to use for GET/HEAD/POST. Defaults to 302.
+*/
+function inertiaRedirectStatus(method, fallback = 302) {
+	const m = method.toUpperCase();
+	if (m === "PUT" || m === "PATCH" || m === "DELETE" || m === "QUERY") return 303;
+	return fallback;
+}
+//#endregion
+//#region src/core/render.ts
+/**
+* Resolve a `SharedPropsInput` to a plain props object. Returns `{}` for
+* undefined/null inputs or when the resolver returns nullish.
+*
+* @param shared Static props object, a (possibly async) function, or undefined.
+* @param req Request passed to the resolver when `shared` is a function.
+*/
+async function evaluateShared(shared, req) {
+	if (shared === void 0 || shared === null) return {};
+	if (typeof shared === "function") return await shared(req) ?? {};
+	return shared;
+}
+/**
+* Build the final {@link InertiaPage} object given a controller's component
+* + props, the request info, and configured shared props / version.
+*
+* Returned page is suitable for either:
+*   - JSON serialization on `X-Inertia` requests, or
+*   - embedding into the root HTML view via a `<script>` page tag.
+*
+* @param input Component, props, parsed request, shared resolver, version,
+*   optional `clearHistory` / `encryptHistory` / `preserveFragment` flags, and
+*   an optional rescue handler.
+*/
+async function buildPage(input) {
+	const sharedProps = await evaluateShared(input.shared, input.req);
+	const resolved = await resolveProps({
+		props: input.props,
+		shared: sharedProps,
+		component: input.component,
+		request: input.request,
+		onRescue: input.onRescue
+	});
+	return createPage({
+		component: input.component,
+		props: resolved.props,
+		url: input.request.url,
+		version: input.version,
+		clearHistory: input.options?.clearHistory,
+		encryptHistory: input.options?.encryptHistory,
+		preserveFragment: input.options?.preserveFragment,
+		metadata: resolved.metadata,
+		flash: input.flash
+	});
+}
+//#endregion
+//#region src/core/versioning.ts
+/**
+* Resolve a version value (string, async function, or null) against a request.
+*
+* Returns `null` when no version is configured — in which case asset version
+* mismatch detection is disabled.
+*
+* @param resolver Static version string, a (possibly async) function, or undefined.
+* @param req Request passed to the resolver when it is a function.
+*/
+async function resolveVersion(resolver, req) {
+	if (resolver === void 0 || resolver === null) return null;
+	if (typeof resolver === "string") return resolver;
+	return await resolver(req) ?? null;
+}
+/**
+* Returns true if the client's version (`X-Inertia-Version`) does not match
+* the server's current version. Mismatches on GET requests should trigger a
+* full reload via the `X-Inertia-Location` mechanism.
+*
+* @param serverVersion Currently configured server version; `null` disables checks.
+* @param clientVersion Value of the `X-Inertia-Version` header; `null` is treated as empty.
+*/
+function isVersionMismatch(serverVersion, clientVersion) {
+	if (serverVersion === null) return false;
+	return serverVersion !== (clientVersion ?? "");
+}
+//#endregion
+export { isPropDescriptor as A, matchesExcept as C, always as D, unpackDotProps as E, scroll as F, PropDescriptor as I, merge as M, once as N, deepMerge as O, optional as P, leadsToOnly as S, pathIsSameOrDescendant as T, computeSsrCacheKey as _, INERTIA_REDIRECT_STATUS as a, PropsResolver as b, encodePageScript as c, INERTIA_HEADERS as d, PREFETCH_HEADERS as f, canonicalStringify as g, scopeErrors as h, INERTIA_LOCATION_STATUS as i, live as j, defer as k, renderDefaultHtml as l, resolveValidationErrors as m, resolveVersion as n, inertiaRedirectStatus as o, parseInertiaRequest as p, buildPage as r, createPage as s, isVersionMismatch as t, renderErrorPage as u, broadcastProps as v, matchesOnly as w, resolveProps as x, resolveBroadcastProps as y };
+
+//# sourceMappingURL=core-PN_yVSCS.js.map