@blacklizard/inertia-express 0.1.0

package/dist/express/index.js

@@ -0,0 +1,854 @@
+import { INERTIA_HEADERS, INERTIA_LOCATION_STATUS, INERTIA_REDIRECT_STATUS, always, buildPage, canonicalStringify, computeSsrCacheKey, deepMerge, defer, encodePageScript, inertiaRedirectStatus, isVersionMismatch, lazy, merge, optional, parseInertiaRequest, renderDefaultHtml, resolveVersion, scopeErrors } from "../core/index.js";
+import { createHash } from "node:crypto";
+import { format } from "node:util";
+import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+//#region src/express/edge-cache.ts
+/**
+* Apply an edge-cache decision to the response. Called automatically by
+* the middleware when an `edgeCache` policy is configured. Exported so
+* you can call it from custom code paths too.
+*
+* No-op when `decision` is `null`, when `sMaxAge <= 0`, or when the response
+* is 3xx+ (4xx/5xx must not be cached at the edge). The middleware also skips
+* Inertia XHR responses before calling this — that filter lives at the call
+* site, not here, since `applyEdgeCache` only sees the decision + status.
+*
+* `Vary` values from the decision are merged into the existing header,
+* de-duplicated by trimmed string.
+*
+* @param decision Policy output (or `null` to opt out).
+* @param res Outgoing Express response (mutated: sets `Cache-Control`, `Vary`).
+*/
+function applyEdgeCache(decision, res) {
+	if (decision === null || decision.sMaxAge <= 0) return;
+	if (res.statusCode >= 300) return;
+	const parts = [
+		"public",
+		`s-maxage=${decision.sMaxAge}`,
+		`max-age=${decision.maxAge ?? 0}`
+	];
+	if (decision.staleWhileRevalidate && decision.staleWhileRevalidate > 0) parts.push(`stale-while-revalidate=${decision.staleWhileRevalidate}`);
+	res.setHeader("Cache-Control", parts.join(", "));
+	if (decision.vary && decision.vary.length > 0) {
+		const existing = res.getHeader("Vary");
+		const all = /* @__PURE__ */ new Set();
+		if (typeof existing === "string") existing.split(",").forEach((v) => all.add(v.trim()));
+		decision.vary.forEach((v) => {
+			const trimmed = v.trim();
+			if (trimmed) all.add(trimmed);
+		});
+		res.setHeader("Vary", Array.from(all).join(", "));
+	}
+}
+//#endregion
+//#region src/express/response.ts
+/**
+* Resolve the shared-props input for a request. When `flashFromSession` is
+* enabled, session-stored validation errors and flash data are merged in
+* automatically (read-once — they are cleared after being read). Explicit
+* `sharedProps` keys win on collision.
+*
+* @param ctx Render context carrying the middleware options.
+* @param res Express response, scanned for `res.locals.inertiaErrors` as a
+*   fallback when no session is wired.
+*/
+function composeSharedProps(ctx, res) {
+	const base = ctx.options.sharedProps;
+	if (!ctx.options.flashFromSession) return base ?? {};
+	return async (req) => {
+		let baseProps = {};
+		if (base) baseProps = typeof base === "function" ? await base(req) ?? {} : base;
+		const { session } = req;
+		const errors = session?.errors ?? res.locals.inertiaErrors ?? {};
+		const flash = session?.flash ?? null;
+		if (session) {
+			session.errors = void 0;
+			session.flash = void 0;
+		}
+		return {
+			errors,
+			flash,
+			...baseProps
+		};
+	};
+}
+/**
+* Send the Inertia version-mismatch response: 409 with `X-Inertia-Location`
+* pointing back at the same URL so the client performs a hard reload.
+*
+* @param res Outgoing Express response.
+* @param url Location to send the client to (typically the requested URL).
+*/
+function sendVersionMismatch(res, url) {
+	res.status(409).setHeader(INERTIA_HEADERS.location, url).end();
+}
+/**
+* Send an external Inertia redirect. For Inertia (XHR) requests this returns
+* 409 + `X-Inertia-Location` so the client performs a window.location nav.
+* For plain browser requests it falls back to a normal 302 redirect.
+*
+* @param req Incoming Express request; `req.inertia` is reused when present.
+* @param res Outgoing Express response.
+* @param target Destination URL.
+*/
+function sendInertiaLocation(req, res, target) {
+	if ((req.inertia ?? parseInertiaRequest({
+		headers: req.headers,
+		method: req.method,
+		url: req.originalUrl ?? req.url
+	})).isInertia) {
+		res.status(409).setHeader(INERTIA_HEADERS.location, target).end();
+		return;
+	}
+	res.redirect(302, target);
+}
+/**
+* Merge `Accept` and `X-Inertia` into an existing `Vary` header value,
+* deduplicating case-insensitively so the header never accumulates repeats
+* when the middleware and the response both contribute tokens.
+*
+* @param existing Current header value as Node returns it (string, number,
+*   string[], or undefined).
+*/
+function mergeVary(existing) {
+	const tokens = [];
+	const seen = /* @__PURE__ */ new Set();
+	const add = (token) => {
+		const trimmed = token.trim();
+		const key = trimmed.toLowerCase();
+		if (trimmed && !seen.has(key)) {
+			seen.add(key);
+			tokens.push(trimmed);
+		}
+	};
+	if (existing !== void 0) String(existing).split(",").forEach((part) => add(part));
+	add("Accept");
+	add("X-Inertia");
+	return tokens.join(", ");
+}
+/**
+* Coerce SSR head output (string, string[], or absent) to a single string
+* suitable for injection into the document `<head>`.
+*
+* @param head Head fragment(s) from the SSR renderer.
+*/
+function flattenSsrHead(head) {
+	if (head === void 0) return;
+	if (Array.isArray(head)) return head.join("");
+	return head;
+}
+/**
+* Default rule deciding whether a rendered page is safe to cache. Cacheable
+* iff the request is a non-Inertia GET and the page carries no flash
+* messages or validation errors (those are per-visit state).
+*
+* @param input Express request and the resolved page object.
+*/
+function defaultCacheVary(input) {
+	const { req, page } = input;
+	if (req.method !== "GET") return false;
+	if (req.inertia?.isInertia) return false;
+	const props = page.props;
+	if (props && typeof props === "object") {
+		const flash = props.flash;
+		if (flash && Object.keys(flash).length > 0) return false;
+		const errors = props.errors;
+		if (errors && Object.keys(errors).length > 0) return false;
+	}
+	return true;
+}
+/**
+* Wrap `cache.store.get` so a thrown store error is reported via `onError`
+* and reported as a miss instead of bubbling out to the request handler.
+*
+* @param cache Resolved cache options.
+* @param key Cache key.
+*/
+async function safeCacheGet(cache, key) {
+	try {
+		return await cache.store.get(key);
+	} catch (err) {
+		cache.onError?.("get", err);
+		return null;
+	}
+}
+/**
+* Wrap `cache.store.set` so a thrown store error is reported via `onError`
+* but never propagates — cache writes are fire-and-forget.
+*
+* @param cache Resolved cache options.
+* @param key Cache key.
+* @param entry Value to store.
+* @param ttl Time-to-live in seconds.
+*/
+async function safeCacheSet(cache, key, entry, ttl) {
+	try {
+		await cache.store.set(key, entry, ttl);
+	} catch (err) {
+		cache.onError?.("set", err);
+	}
+}
+/**
+* Render the final HTML body. When an SSR result is available, expose it via
+* `res.locals.ssr` so a custom `rootView` can read it, then either call
+* `rootView` or fall back to {@link renderDefaultHtml}.
+*
+* @param ctx Render context carrying the middleware options.
+* @param page Resolved page object.
+* @param ssrResult SSR renderer output, or `null` when SSR is skipped.
+* @param req Incoming request.
+* @param res Outgoing response.
+*/
+async function renderRootViewWithSsr(ctx, page, ssrResult, req, res) {
+	if (ssrResult) {
+		res.locals.ssr = ssrResult;
+		if (ctx.options.rootView) return ctx.options.rootView({
+			page,
+			req,
+			res
+		});
+		return renderDefaultHtml({
+			page,
+			head: flattenSsrHead(ssrResult.head),
+			ssrBody: ssrResult.bodyIsFullRoot ? void 0 : ssrResult.body,
+			ssrFull: ssrResult.bodyIsFullRoot ? ssrResult.body : void 0
+		});
+	}
+	if (ctx.options.rootView) return ctx.options.rootView({
+		page,
+		req,
+		res
+	});
+	return renderDefaultHtml({ page });
+}
+/**
+* Apply the configured `edgeCache` policy unless this is an Inertia XHR
+* response (those vary per visit and must not be cached at the edge).
+*
+* @param ctx Render context carrying the middleware options.
+* @param page Resolved page object.
+* @param req Incoming request.
+* @param res Outgoing response.
+*/
+function maybeApplyEdgeCache(ctx, page, req, res) {
+	if (!ctx.options.edgeCache) return;
+	if (req.inertia?.isInertia) return;
+	applyEdgeCache(ctx.options.edgeCache({
+		req,
+		res,
+		page
+	}), res);
+}
+/**
+* Build and send an Inertia response. Handles version-mismatch detection,
+* partial-reload filtering, JSON vs HTML, SSR, view caching, and edge
+* cache headers. The status code already on `res` (e.g. `res.status(404)`)
+* is preserved on both the JSON and HTML branches.
+*
+* @param req Incoming Express request.
+* @param res Outgoing Express response.
+* @param ctx Render context carrying the middleware options.
+* @param component Inertia component name to render.
+* @param props Page-specific props (merged with shared props).
+* @param options Optional per-response overrides (url, clearHistory, encryptHistory).
+*/
+async function sendInertiaResponse(req, res, ctx, component, props, options = {}) {
+	const info = req.inertia ?? parseInertiaRequest({
+		headers: req.headers,
+		method: req.method,
+		url: options.url ?? req.originalUrl ?? req.url
+	});
+	const url = options.url ?? info.url;
+	const version = await resolveVersion(ctx.options.version, req);
+	if (info.isInertia && info.method === "GET" && isVersionMismatch(version, info.version)) {
+		sendVersionMismatch(res, url);
+		return;
+	}
+	const page = await buildPage({
+		component,
+		props,
+		request: {
+			...info,
+			url
+		},
+		req,
+		shared: composeSharedProps(ctx, res),
+		version,
+		options: {
+			clearHistory: options.clearHistory,
+			encryptHistory: options.encryptHistory
+		}
+	});
+	res.setHeader("Vary", mergeVary(res.getHeader("Vary")));
+	if (info.isInertia) {
+		res.status(res.statusCode).setHeader("Content-Type", "application/json; charset=utf-8").setHeader(INERTIA_HEADERS.inertia, "true");
+		res.send(JSON.stringify(page));
+		return;
+	}
+	const { cache } = ctx.options;
+	const cacheVary = cache?.vary ?? defaultCacheVary;
+	const cacheable = cache !== void 0 && cacheVary({
+		req,
+		page
+	});
+	let cacheKey = null;
+	if (cacheable && cache) {
+		cacheKey = computeSsrCacheKey({
+			prefix: cache.keyPrefix ?? "inertia:ssr",
+			version,
+			component,
+			props: page.props,
+			discriminator: cache.discriminator?.(req)
+		});
+		const hit = await safeCacheGet(cache, cacheKey);
+		if (hit) {
+			res.setHeader("X-Inertia-Cache", "HIT");
+			const html = await renderRootViewWithSsr(ctx, hit.page, {
+				head: hit.head,
+				body: hit.body,
+				bodyIsFullRoot: hit.bodyIsFullRoot
+			}, req, res);
+			maybeApplyEdgeCache(ctx, hit.page, req, res);
+			res.status(res.statusCode).setHeader("Content-Type", "text/html; charset=utf-8").send(html);
+			return;
+		}
+		res.setHeader("X-Inertia-Cache", "MISS");
+	}
+	let ssrResult = null;
+	if (ctx.options.ssr) ssrResult = await ctx.options.ssr({
+		page,
+		req,
+		res
+	});
+	const html = await renderRootViewWithSsr(ctx, page, ssrResult, req, res);
+	if (cacheable && cache && cacheKey && ssrResult) {
+		const entry = {
+			head: ssrResult.head ?? "",
+			body: ssrResult.body,
+			bodyIsFullRoot: ssrResult.bodyIsFullRoot,
+			storedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			page
+		};
+		safeCacheSet(cache, cacheKey, entry, cache.ttlSeconds ?? 300).catch(() => {});
+	}
+	maybeApplyEdgeCache(ctx, page, req, res);
+	res.status(res.statusCode).setHeader("Content-Type", "text/html; charset=utf-8").send(html);
+}
+//#endregion
+//#region src/express/middleware.ts
+/**
+* Build the `connect-flash`-compatible `req.flash()` method for a request.
+* Provided so this package is a drop-in replacement for `connect-flash`: the
+* returned function matches its semantics exactly — a setter call appends to
+* a per-type bucket in `req.session.flash` and returns the new bucket length,
+* a getter call reads and clears. Throws when no session is wired, just like
+* `connect-flash`.
+*
+* @param req Express request whose `session` holds the flash buckets.
+*/
+function createFlash(req) {
+	return ((type, msg, ...rest) => {
+		const { session } = req;
+		if (session === void 0) throw new Error("req.flash() requires sessions");
+		const msgs = session.flash ?? {};
+		session.flash = msgs;
+		if (type && msg) {
+			let bucket = msgs[type];
+			if (bucket === void 0) {
+				bucket = [];
+				msgs[type] = bucket;
+			}
+			if (rest.length > 0) return bucket.push(format(msg, ...rest));
+			if (Array.isArray(msg)) {
+				msg.forEach((val) => bucket.push(val));
+				return bucket.length;
+			}
+			return bucket.push(msg);
+		}
+		if (type) {
+			const arr = msgs[type] ?? [];
+			delete msgs[type];
+			return arr;
+		}
+		session.flash = {};
+		return msgs;
+	});
+}
+/**
+* Create the Inertia.js Express middleware.
+*
+* The middleware:
+*   - Parses Inertia headers into `req.inertia`.
+*   - Adds `req.flash(type?, msg?)` — a `connect-flash`-compatible API.
+*   - Adds `res.inertia(component, props, options)`.
+*   - Adds `res.inertiaLocation(url)` for external redirects.
+*   - Adds `res.inertiaErrors(errors, bag?)` to flash validation errors.
+*   - Adds `res.inertiaFlash(data)` to flash arbitrary data.
+*   - Auto-promotes redirects after PUT/PATCH/DELETE to 303 for Inertia visits.
+*
+* Mount before your route handlers:
+*
+* ```ts
+* app.use(inertia({ rootView: ..., sharedProps: ... }));
+* ```
+*
+* @param options Middleware configuration; defaults to an empty object.
+*/
+function inertia(options = {}) {
+	const ctx = { options };
+	return function inertiaMiddleware(req, res, next) {
+		const info = parseInertiaRequest({
+			headers: req.headers,
+			method: req.method,
+			url: req.originalUrl ?? req.url
+		});
+		req.inertia = info;
+		req.flash = createFlash(req);
+		res.inertia = async (component, props = {}, opts = {}) => {
+			try {
+				await sendInertiaResponse(req, res, ctx, component, props, opts);
+			} catch (err) {
+				next(err);
+			}
+		};
+		res.inertiaLocation = (url) => {
+			sendInertiaLocation(req, res, url);
+		};
+		res.inertiaErrors = (errors, bag) => {
+			const { session } = req;
+			const scoped = scopeErrors(errors, bag ?? null);
+			if (session) session.errors = {
+				...session.errors ?? {},
+				...scoped.errors
+			};
+			else res.locals.inertiaErrors = scoped.errors;
+		};
+		res.inertiaFlash = (data) => {
+			const { session } = req;
+			if (session) session.flash = data;
+		};
+		if (info.isInertia) {
+			const originalRedirect = res.redirect.bind(res);
+			res.redirect = ((arg1, arg2) => {
+				let status;
+				let url;
+				if (typeof arg1 === "number") {
+					status = arg1;
+					url = String(arg2);
+				} else {
+					status = inertiaRedirectStatus(req.method, 302);
+					url = arg1;
+				}
+				if (status === 302 && (req.method === "PUT" || req.method === "PATCH" || req.method === "DELETE")) status = 303;
+				originalRedirect(status, url);
+			});
+		}
+		if (!res.getHeader("Vary")) res.setHeader("Vary", "Accept, X-Inertia");
+		next();
+	};
+}
+//#endregion
+//#region src/express/memory-store.ts
+/**
+* Build an in-process LRU + TTL {@link SsrCacheStore}. See
+* {@link MemoryCacheStoreOptions} for the full contract.
+*
+* @param options Store configuration; defaults applied when omitted.
+*/
+function createMemoryCacheStore(options = {}) {
+	const max = options.max ?? 500;
+	const map = /* @__PURE__ */ new Map();
+	/**
+	* Drop oldest-inserted entries until `map.size <= max`. Relies on `Map`'s
+	* insertion-order iteration to identify the LRU entry.
+	*/
+	function evict() {
+		while (map.size > max) {
+			const oldest = map.keys().next().value;
+			if (oldest === void 0) return;
+			map.delete(oldest);
+		}
+	}
+	return {
+		/**
+		* Return the cached entry or `null` on miss / expired. Touched entries
+		* are reinserted so they become the most-recently-used.
+		*
+		* @param key Cache key.
+		*/
+		async get(key) {
+			const slot = map.get(key);
+			if (!slot) return null;
+			if (slot.expiresAt < Date.now()) {
+				map.delete(key);
+				return null;
+			}
+			map.delete(key);
+			map.set(key, slot);
+			return slot.entry;
+		},
+		/**
+		* Write an entry with the given TTL, replacing any prior value. Runs LRU
+		* eviction afterward so `max` is never exceeded.
+		*
+		* @param key Cache key.
+		* @param entry Value to store.
+		* @param ttlSeconds Time-to-live in seconds.
+		*/
+		async set(key, entry, ttlSeconds) {
+			const expiresAt = Date.now() + ttlSeconds * 1e3;
+			map.delete(key);
+			map.set(key, {
+				entry,
+				expiresAt
+			});
+			evict();
+		},
+		/**
+		* Remove an entry. Idempotent — missing keys are silently ignored.
+		*
+		* @param key Cache key.
+		*/
+		async delete(key) {
+			map.delete(key);
+		}
+	};
+}
+//#endregion
+//#region src/express/prerender.ts
+/**
+* Map an HTTP route to an on-disk static-output path. `/` maps to
+* `<outDir>/index.html`; `/foo/bar` to `<outDir>/foo/bar/index.html`.
+* Query strings are stripped before computing the path — reverse proxies
+* (nginx, Caddy, CloudFront) split the URL at `?` when looking up static
+* files, so embedding the query string in a directory name produces a path
+* that can never be served.
+*
+* @param outDir Static-output root.
+* @param route HTTP path (with optional query string) being prerendered.
+*/
+function routeToFile(outDir, route) {
+	const { pathname } = new URL(route, "http://x");
+	const trimmed = pathname.replace(/^\/+/, "").replace(/\/+$/, "");
+	if (!trimmed) return join(outDir, "index.html");
+	return join(outDir, trimmed, "index.html");
+}
+/**
+* Write the rendered HTML to disk when the mode includes static output.
+* Returns the file path written, or `undefined` for warmup-only modes.
+* Throws when static output is requested without an `outDir`.
+*
+* @param options Shared prerender options — `outDir` lives here.
+* @param route HTTP path being rendered; mapped to the on-disk path.
+* @param html Rendered response body to write.
+* @param mode Resolved output mode for this run.
+*/
+async function maybeWriteStatic(options, route, html, mode) {
+	if (mode !== "static" && mode !== "both") return;
+	if (!options.outDir) throw new Error(`outDir is required when mode is "${mode}"`);
+	const outputPath = routeToFile(options.outDir, route);
+	await mkdir(dirname(outputPath), { recursive: true });
+	await writeFile(outputPath, html, "utf8");
+	return outputPath;
+}
+/**
+* Fetch a single route, optionally write its body to disk, and return a
+* {@link PrerenderRouteResult}. Never throws — failures are returned with
+* `status: null` and an `error` message so the calling loop keeps going.
+*
+* @param options Shared prerender options (baseUrl, mode, outDir, etc.).
+* @param route HTTP path to render.
+*/
+async function runOne(options, route) {
+	const fetchImpl = options.fetch ?? fetch;
+	const mode = options.mode ?? "warmup";
+	const start = Date.now();
+	const ctrl = new AbortController();
+	const timer = setTimeout(() => ctrl.abort(), options.timeoutMs ?? 3e4);
+	try {
+		const res = await fetchImpl(new URL(route, options.baseUrl).toString(), {
+			method: "GET",
+			headers: {
+				Accept: "text/html",
+				...options.headers
+			},
+			signal: ctrl.signal
+		});
+		const html = await res.text();
+		const outputPath = await maybeWriteStatic(options, route, html, mode);
+		return {
+			route,
+			status: res.status,
+			bytes: Buffer.byteLength(html),
+			outputPath,
+			durationMs: Date.now() - start
+		};
+	} catch (err) {
+		return {
+			route,
+			status: null,
+			bytes: 0,
+			error: err.message,
+			durationMs: Date.now() - start
+		};
+	} finally {
+		clearTimeout(timer);
+	}
+}
+/**
+* Run the prerender pipeline. Programmatic entry-point for the
+* `bin/inertia-prerender` CLI.
+*
+* Two output modes (which can be combined via `"both"`):
+*
+* - **`warmup`** (default) — fetches each route, discards the body. Use to
+*   populate the SSR view cache after a deploy so the first real visitor
+*   doesn't pay the SSR latency cost.
+* - **`static`** — fetches each route and writes the response body to
+*   `<outDir>/<route>/index.html`. Serve those files directly via
+*   nginx/CDN, bypassing Express entirely.
+*
+* Bounded-concurrency: `concurrency` workers consume routes from a shared
+* counter; the returned `results` preserve input order. Failures on
+* individual routes never halt the run — the per-route summary lets a CI
+* step choose to fail-loud.
+*
+* @param options Pipeline configuration — see {@link PrerenderOptions}.
+*/
+async function prerender(options) {
+	const concurrency = Math.max(1, options.concurrency ?? 4);
+	const results = new Array(options.routes.length);
+	let next = 0;
+	/**
+	* Claim the next route index and process it, then recurse. Recursion
+	* (instead of a loop) avoids both `while`-spin and `no-await-in-loop`.
+	*/
+	async function worker() {
+		const i = next;
+		next += 1;
+		if (i >= options.routes.length) return;
+		results[i] = await runOne(options, options.routes[i] ?? "");
+		await worker();
+	}
+	await Promise.all(Array.from({ length: Math.min(concurrency, options.routes.length) }, async () => worker()));
+	const ok = results.filter((r) => r && r.status !== null && r.status < 400 && !r.error).length;
+	const failed = results.length - ok;
+	return {
+		total: results.length,
+		ok,
+		failed,
+		results
+	};
+}
+//#endregion
+//#region src/express/ssr-fetcher.ts
+const EMPTY_RESULT = {
+	body: "",
+	head: ""
+};
+/**
+* Resolve after the given number of milliseconds.
+*
+* @param ms Delay in milliseconds.
+*/
+async function sleep(ms) {
+	return new Promise((resolve) => {
+		setTimeout(resolve, ms);
+	});
+}
+/**
+* Build an {@link SsrRenderer} that POSTs the page object to a separate Node
+* SSR process (or load-balanced pool) and returns the rendered
+* `{ head, body }`.
+*
+* Matches the wire protocol used by `@inertiajs/{vue3,react,svelte}/server`
+* `createServer()`: `POST <url>` with `application/json` body containing the
+* page object, response is `{ head: string[], body: string }`.
+*
+* Adds production hardening on top of the bare protocol:
+*   - Per-attempt timeout (default 5000ms) via `AbortController`.
+*   - Recursive retry with exponential backoff (`retryBaseMs * 2^attempt`).
+*   - Circuit breaker — opens after `breakerThreshold` consecutive failed
+*     *requests* (not attempts); half-opens after `breakerCooldownMs` so a
+*     probe request can re-close it on success.
+*   - `fallback`: `"client"` returns an empty SSR result so the client
+*     renders alone; `"throw"` rethrows so Express's error handler can react.
+*
+* @param options Fetcher configuration — see {@link InertiaSsrFetcherOptions}.
+*/
+function createInertiaSsrFetcher(options) {
+	const fetchImpl = options.fetch ?? fetch;
+	const timeoutMs = options.timeoutMs ?? 5e3;
+	const retries = options.retries ?? 2;
+	const retryBaseMs = options.retryBaseMs ?? 100;
+	const breakerThreshold = options.breakerThreshold ?? 5;
+	const breakerCooldownMs = options.breakerCooldownMs ?? 3e4;
+	const fallback = options.fallback ?? "client";
+	const breakerEnabled = breakerThreshold > 0 && Number.isFinite(breakerThreshold);
+	const state = {
+		failures: 0,
+		openedAt: null
+	};
+	/**
+	* Returns `true` while the breaker is open and within its cooldown window;
+	* a return of `false` after a previous failure means we are half-open and
+	* the caller may attempt a probe request.
+	*/
+	function breakerOpen() {
+		if (!breakerEnabled || state.openedAt === null) return false;
+		if (Date.now() - state.openedAt >= breakerCooldownMs) return false;
+		return true;
+	}
+	/**
+	* Reset the breaker after a successful render.
+	*/
+	function recordSuccess() {
+		state.failures = 0;
+		state.openedAt = null;
+	}
+	/**
+	* Increment the failure counter; open the breaker when the threshold is hit.
+	*/
+	function recordFailure() {
+		state.failures += 1;
+		if (breakerEnabled && state.failures >= breakerThreshold) state.openedAt = Date.now();
+	}
+	/**
+	* Fire one SSR request — the unit the retry loop wraps. Throws on
+	* timeout, network error, or non-2xx response.
+	*
+	* @param page Page object to send to the SSR server.
+	*/
+	async function attempt(page) {
+		const controller = new AbortController();
+		const timer = setTimeout(() => controller.abort(), timeoutMs);
+		try {
+			const res = await fetchImpl(options.url, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					...options.headers
+				},
+				body: JSON.stringify(page),
+				signal: controller.signal
+			});
+			if (!res.ok) throw new Error(`Inertia SSR request failed: ${res.status} ${res.statusText}`);
+			const json = await res.json();
+			return {
+				body: json.body ?? "",
+				head: json.head,
+				bodyIsFullRoot: json.bodyIsFullRoot
+			};
+		} finally {
+			clearTimeout(timer);
+		}
+	}
+	return async ({ page }) => {
+		if (breakerOpen()) {
+			if (fallback === "throw") throw new Error("Inertia SSR circuit breaker is open");
+			return EMPTY_RESULT;
+		}
+		/**
+		* Run one render attempt, recursing with exponential backoff until the
+		* retry budget is spent. Records breaker success on the first win.
+		*
+		* @param remaining Retry attempts left before the error propagates.
+		*/
+		const attemptWithRetry = async (remaining) => {
+			try {
+				const result = await attempt(page);
+				recordSuccess();
+				return result;
+			} catch (err) {
+				if (remaining <= 0) throw err;
+				await sleep(retryBaseMs * 2 ** (retries - remaining));
+				return attemptWithRetry(remaining - 1);
+			}
+		};
+		try {
+			return await attemptWithRetry(retries);
+		} catch (lastError) {
+			recordFailure();
+			if (fallback === "throw") throw lastError;
+			return EMPTY_RESULT;
+		}
+	};
+}
+//#endregion
+//#region src/express/vite-manifest.ts
+/**
+* Build a stable asset version from a Vite-generated `manifest.json`.
+*
+* Compatible with both `@inertiajs/vite-plugin` output and the standard
+* `--manifest` option from `vite build`. The returned function is suitable
+* to pass directly as the `version` option of the Inertia middleware.
+*
+* Strategy:
+*   - Read the manifest file.
+*   - Hash a canonicalized list of `(key -> file)` entries (only the `file`
+*     field per entry, so unrelated manifest metadata never perturbs the hash).
+*   - Cache the result; re-read only after the file's mtime changes (when
+*     `watchMtime` is true) or never re-read (when false).
+*   - Returns `null` when the manifest file is absent or unparseable.
+*
+* A new manifest (different hashed output paths) yields a new version, which
+* the middleware embeds in the SSR cache key — so a deploy atomically
+* invalidates every existing cache entry.
+*
+* @param options Path to the manifest plus the mtime-watch flag.
+*/
+function viteManifestVersion(options) {
+	const watchMtime = options.watchMtime ?? true;
+	let cached = null;
+	/**
+	* Resolve to the current version string, or `null` when the manifest can't
+	* be read or parsed. Hits the in-memory cache when the mtime is unchanged.
+	*/
+	async function read() {
+		let mtimeMs;
+		try {
+			mtimeMs = (await stat(options.manifestPath)).mtimeMs;
+		} catch {
+			return null;
+		}
+		if (cached && (!watchMtime || cached.mtimeMs === mtimeMs)) return cached.version;
+		let raw;
+		try {
+			raw = await readFile(options.manifestPath, "utf8");
+		} catch {
+			return null;
+		}
+		let parsed;
+		try {
+			parsed = JSON.parse(raw);
+		} catch {
+			return null;
+		}
+		const lines = Object.keys(parsed).sort().map((key) => {
+			const entry = parsed[key];
+			if (entry && typeof entry === "object" && "file" in entry) return `${key}=${entry.file}`;
+			return `${key}=${JSON.stringify(entry)}`;
+		});
+		const version = createHash("sha256").update(lines.join("\n")).digest("hex").slice(0, 16);
+		cached = {
+			mtimeMs,
+			version
+		};
+		return version;
+	}
+	return read;
+}
+//#endregion
+//#region src/express/index.ts
+/**
+* Express adapter for Inertia.js v3.
+*
+* Default entry point of `@blacklizard/inertia-express`. The framework-agnostic
+* core is available at `@blacklizard/inertia-express/core`.
+*/
+var express_default = inertia;
+//#endregion
+export { INERTIA_HEADERS, INERTIA_LOCATION_STATUS, INERTIA_REDIRECT_STATUS, always, applyEdgeCache, canonicalStringify, computeSsrCacheKey, createInertiaSsrFetcher, createMemoryCacheStore, deepMerge, express_default as default, defer, encodePageScript, inertia, lazy, merge, optional, prerender, sendInertiaLocation, sendInertiaResponse, sendVersionMismatch, viteManifestVersion };
+
+//# sourceMappingURL=index.js.map