@blacklizard/inertia-express 3.0.0 → 3.1.0

package/dist/{core-ChQbBw-k.js → core-PN_yVSCS.js}

@@ -1,49 +1,39 @@
 import { createHash } from "node:crypto";
-//#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])]));
-}
+//#region src/core/prop-descriptor.ts
 /**
-* 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.
+* 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 canonicalStringify(value) {
-	return JSON.stringify(canonicalize(value));
+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-"
+};
 /**
-* 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.
+* 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 Prefix, version, component, resolved props, optional discriminator.
+* @param input Bare channel name or explicit channel.
 */
-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}`;
+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
+	};
 }
-//#endregion
-//#region src/core/prop-descriptor.ts
 /**
 * A prop wrapped with resolution and merge behaviour, ported from
 * inertia-laravel's prop classes and their `MergesProps`, `DefersProps`
@@ -72,6 +62,8 @@ var PropDescriptor = class {
 	isScroll = false;
 	wrapper = "data";
 	scrollMetadata = null;
+	liveDeclarations = [];
+	liveThrottle = null;
 	/**
 	* Create a descriptor around a prop source.
 	*
@@ -97,9 +89,16 @@ var PropDescriptor = class {
 		return !this.appends && this.mergesAtRoot();
 	}
 	/**
-	* Mark the prop for a shallow client-side merge.
+	* `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;
 	}
@@ -229,6 +228,48 @@ var PropDescriptor = class {
 		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() {
@@ -319,6 +360,16 @@ function always(value) {
 	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.
@@ -450,359 +501,84 @@ async function unpackDotProps(props) {
 	}, Promise.resolve({ ...props }));
 }
 //#endregion
-//#region src/core/errors.ts
+//#region src/core/partial-filter.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`.
+* `true` when `path` equals `parent` or lies in its dot-notation subtree.
 *
-* @param errors Flat field-to-message map.
-* @param bag Optional error-bag name (e.g. `"createUser"`); null for top-level.
+* @param path Dot-notation prop path to test.
+* @param parent Dot-notation path that may contain `path`.
 */
-function scopeErrors(errors, bag) {
-	if (bag) return { errors: { [bag]: errors } };
-	return { errors };
+function pathIsSameOrDescendant(path, parent) {
+	return path === parent || path.startsWith(`${parent}.`);
 }
-//#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"
-};
 /**
-* 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.
+* `true` when `path` matches an `only` entry or is a descendant of one.
 *
-* @param headers Raw header record from the HTTP layer.
-* @param name Header name to read.
+* @param path Dot-notation prop path to test.
+* @param only Requested partial-reload `only` paths.
 */
-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;
+function matchesOnly(path, only) {
+	return only.some((onlyPath) => pathIsSameOrDescendant(path, onlyPath));
 }
 /**
-* Split a comma-separated header value into a trimmed, non-empty string list.
-* Returns `null` when the input is null or yields no entries.
+* `true` when `path` is a strict ancestor of an `only` entry.
 *
-* @param value Raw header value, or null when absent.
+* @param path Dot-notation prop path to test.
+* @param only Requested partial-reload `only` paths.
 */
-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;
+function leadsToOnly(path, only) {
+	return only.some((onlyPath) => onlyPath.startsWith(`${path}.`));
 }
 /**
-* Parse a request's headers into a normalized {@link InertiaRequestInfo}.
+* `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 input Headers, HTTP method, and request URL. Method is uppercased in
-*   the returned object; the URL is passed through unchanged.
+* @param path Dot-notation prop path to test.
+* @param except Requested partial-reload `except` paths.
 */
-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,
-		method: input.method.toUpperCase(),
-		url: input.url
-	};
+function matchesExcept(path, except) {
+	return except.some((exceptPath) => pathIsSameOrDescendant(path, exceptPath) || pathIsSameOrDescendant(exceptPath, path));
 }
 //#endregion
-//#region src/core/html.ts
-const HTML_ESCAPES = {
-	"&": "&",
-	"<": "&lt;",
-	">": "&gt;",
-	"\"": "&quot;",
-	"'": "&#39;"
-};
+//#region src/core/props-resolver.ts
 /**
-* Escape characters that would break out of a double-quoted HTML attribute.
+* `true` for arrays and for objects whose prototype is `Object.prototype` or `null`.
 *
-* @param value Raw attribute value.
+* @param value Value to test.
 */
-function escapeHtmlAttribute(value) {
-	return value.replace(/[&<>"']/g, (ch) => HTML_ESCAPES[ch] ?? ch);
+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;
 }
 /**
-* 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 `<`.
+* Normalize a partial header list: empty entries are dropped and an empty list becomes `null`.
 *
-* @param page Resolved Inertia page object.
+* @param list Parsed header list, or `null` when absent.
 */
-function encodePageScript(page) {
-	return JSON.stringify(page).replace(/</g, "\\u003C");
+function normalizeList(list) {
+	const entries = (list ?? []).filter((entry) => entry !== "");
+	return entries.length > 0 ? entries : null;
 }
 /**
-* 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.
+* Default rescue hook: log the rescued error with the prop's path.
 *
-* @param input Page object plus optional title/head/rootId/scriptSrc/SSR markup
-*   — see {@link DefaultRootViewInput}.
+* @param error The thrown value.
+* @param path Dot path of the rescued prop.
 */
-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>`;
+function reportRescuedError(error, path) {
+	console.error(`Inertia prop '${path}' failed to resolve and was rescued.`, error);
 }
-/** 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.
+* Report a failure of a custom rescue hook through the default reporter:
+* the original rescued error, then the hook's own error.
 *
-* @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"
-];
-/**
-* 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/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.
+* @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);
@@ -897,6 +673,7 @@ var PropsResolver = class {
 	rescuedProps = [];
 	scrollProps = Object.create(null);
 	onceProps = Object.create(null);
+	liveProps = Object.create(null);
 	used = false;
 	/**
 	* Create a resolver for one request and component.
@@ -921,8 +698,7 @@ var PropsResolver = class {
 	* @param props Page props; these win over shared props on collision.
 	*/
 	async resolve(shared, props) {
-		if (this.used) throw new Error("PropsResolver.resolve() was already called on this instance; create one resolver per response.");
-		this.used = true;
+		this.markUsed();
 		const combined = {
 			...this.resolveSharedProps(shared),
 			...props
@@ -933,6 +709,55 @@ var PropsResolver = class {
 		};
 	}
 	/**
+	* 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.
 	*
@@ -958,7 +783,8 @@ var PropsResolver = class {
 			["deferredProps", this.deferredProps],
 			["rescuedProps", this.rescuedProps],
 			["scrollProps", this.scrollProps],
-			["onceProps", this.onceProps]
+			["onceProps", this.onceProps],
+			["liveProps", this.liveProps]
 		];
 		return Object.fromEntries(entries.filter(([, value]) => Object.keys(value).length > 0));
 	}
@@ -1112,7 +938,7 @@ var PropsResolver = class {
 	*/
 	include(prop, value, path, parentWasResolved) {
 		this.assertScrollShape(prop, path, value);
-		this.collectMetadata(prop, path, value);
+		this.collectMetadata(prop, path, value, parentWasResolved);
 		if (isPlainObjectOrArray(value)) return this.walk(value, path, parentWasResolved || !isPlainObjectOrArray(prop));
 		return value;
 	}
@@ -1168,6 +994,7 @@ var PropsResolver = class {
 	* @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);
@@ -1279,12 +1106,29 @@ var PropsResolver = class {
 	* @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) {
+	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.
@@ -1393,6 +1237,404 @@ 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
@@ -1407,7 +1649,7 @@ const INERTIA_REDIRECT_STATUS = 303;
 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 the response must be 303
+* 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).
@@ -1415,7 +1657,7 @@ const INERTIA_LOCATION_STATUS = 409;
 */
 function inertiaRedirectStatus(method, fallback = 302) {
 	const m = method.toUpperCase();
-	if (m === "PUT" || m === "PATCH" || m === "DELETE") return 303;
+	if (m === "PUT" || m === "PATCH" || m === "DELETE" || m === "QUERY") return 303;
 	return fallback;
 }
 //#endregion
@@ -1494,6 +1736,6 @@ function isVersionMismatch(serverVersion, clientVersion) {
 	return serverVersion !== (clientVersion ?? "");
 }
 //#endregion
-export { canonicalStringify as A, defer as C, optional as D, once as E, scroll as O, deepMerge as S, merge as T, INERTIA_HEADERS as _, INERTIA_REDIRECT_STATUS as a, unpackDotProps as b, resolveProps as c, matchesOnly as d, pathIsSameOrDescendant as f, renderErrorPage as g, renderDefaultHtml as h, INERTIA_LOCATION_STATUS as i, computeSsrCacheKey as j, PropDescriptor as k, leadsToOnly as l, encodePageScript as m, resolveVersion as n, inertiaRedirectStatus as o, createPage as p, buildPage as r, PropsResolver as s, isVersionMismatch as t, matchesExcept as u, parseInertiaRequest as v, isPropDescriptor as w, always as x, scopeErrors as y };
+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-ChQbBw-k.js.map
+//# sourceMappingURL=core-PN_yVSCS.js.map